diff --git a/ebean-api/pom.xml b/ebean-api/pom.xml
index b6adad05d..c5621372b 100644
--- a/ebean-api/pom.xml
+++ b/ebean-api/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <name>ebean api</name>
@@ -37,26 +37,26 @@
     <dependency>
       <groupId>io.avaje</groupId>
       <artifactId>avaje-jsr305</artifactId>
-      <version>1.0</version>
+      <version>1.1</version>
       <scope>provided</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>persistence-api</artifactId>
-      <version>2.2.4</version>
+      <version>2.2.5</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-annotation</artifactId>
-      <version>7.2</version>
+      <version>7.3</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-types</artifactId>
-      <version>2.1</version>
+      <version>2.2</version>
     </dependency>
 
     <dependency>
@@ -104,6 +104,13 @@
       <optional>true</optional>
     </dependency>
 
+    <dependency>
+      <groupId>io.avaje</groupId>
+      <artifactId>junit</artifactId>
+      <version>1.0</version>
+      <scope>test</scope>
+    </dependency>
+
   </dependencies>
 
   <build>
diff --git a/ebean-api/src/main/java/io/ebean/BeanFinder.java b/ebean-api/src/main/java/io/ebean/BeanFinder.java
index 2c8e04eec..aab61b572 100644
--- a/ebean-api/src/main/java/io/ebean/BeanFinder.java
+++ b/ebean-api/src/main/java/io/ebean/BeanFinder.java
@@ -79,11 +79,11 @@ public abstract class BeanFinder<I,T> {
   /**
    * Creates an entity reference for this ID.
    * <p>
-   * Equivalent to {@link Database#getReference(Class, Object)}
+   * Equivalent to {@link Database#reference(Class, Object)}
    */
   @Nonnull
   public T ref(I id) {
-    return db().getReference(type, id);
+    return db().reference(type, id);
   }
 
   /**
diff --git a/ebean-api/src/main/java/io/ebean/BeanState.java b/ebean-api/src/main/java/io/ebean/BeanState.java
index daf163cc7..20aa0f8e4 100644
--- a/ebean-api/src/main/java/io/ebean/BeanState.java
+++ b/ebean-api/src/main/java/io/ebean/BeanState.java
@@ -57,7 +57,7 @@ public interface BeanState {
    *
    *   // set loaded state on the email property to false so that
    *   // the email property is not included in a stateless update
-   *   DB.getBeanState(user).setPropertyLoaded("email", false);
+   *   DB.beanState(user).setPropertyLoaded("email", false);
    *
    *   user.update();
    *
@@ -72,25 +72,47 @@ public interface BeanState {
    * bean.
    * <p>
    * Accessing another property will cause lazy loading to occur.
-   * </p>
    */
-  Set<String> getLoadedProps();
+  Set<String> loadedProps();
+
+  /**
+   * Deprecated migrate to loadedProps().
+   */
+  @Deprecated
+  default Set<String> getLoadedProps() {
+    return loadedProps();
+  }
 
   /**
    * Return the set of changed properties.
    */
-  Set<String> getChangedProps();
+  Set<String> changedProps();
+
+  /**
+   * Deprecated migrate to changedProps().
+   */
+  @Deprecated
+  default Set<String> getChangedProps() {
+    return changedProps();
+  }
 
   /**
    * Return a map of the updated properties and their new and old values.
    */
-  Map<String, ValuePair> getDirtyValues();
+  Map<String, ValuePair> dirtyValues();
+
+  /**
+   * Deprecated migrate to dirtyValues().
+   */
+  @Deprecated
+  default Map<String, ValuePair> getDirtyValues() {
+    return dirtyValues();
+  }
 
   /**
    * Return true if the bean is readOnly.
    * <p>
    * If a setter is called on a readOnly bean it will throw an exception.
-   * </p>
    */
   boolean isReadOnly();
 
@@ -114,13 +136,29 @@ public interface BeanState {
   void resetForInsert();
 
   /**
-   * Returns a map with load erros.
+   * Returns a map with load errors.
    */
   @Nullable
-  Map<String, Exception> getLoadErrors();
+  Map<String, Exception> loadErrors();
+
+  /**
+   * Deprecated migrate to loadErrors().
+   */
+  @Deprecated
+  default Map<String, Exception> getLoadErrors() {
+    return loadErrors();
+  }
 
   /**
    * Return the sort order value for an order column.
    */
-  int getSortOrder();
+  int sortOrder();
+
+  /**
+   * Deprecated migrate to sortOrder().
+   */
+  @Deprecated
+  default int getSortOrder() {
+    return sortOrder();
+  }
 }
diff --git a/ebean-api/src/main/java/io/ebean/DB.java b/ebean-api/src/main/java/io/ebean/DB.java
index a16ce3513..9bcfb047d 100644
--- a/ebean-api/src/main/java/io/ebean/DB.java
+++ b/ebean-api/src/main/java/io/ebean/DB.java
@@ -126,8 +126,16 @@ public final class DB {
    * an expression that uses OR like Expression e = Expr.or(..., ...);
    * </p>
    */
+  public static ExpressionFactory expressionFactory() {
+    return getDefault().expressionFactory();
+  }
+
+  /**
+   * Deprecated migrate to expressionFactory().
+   */
+  @Deprecated
   public static ExpressionFactory getExpressionFactory() {
-    return getDefault().getExpressionFactory();
+    return expressionFactory();
   }
 
   /**
@@ -650,8 +658,16 @@ public final class DB {
    * @param beanType the type of entity bean
    * @param id       the id value
    */
+  public static <T> T reference(Class<T> beanType, Object id) {
+    return getDefault().reference(beanType, id);
+  }
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
   public static <T> T getReference(Class<T> beanType, Object id) {
-    return getDefault().getReference(beanType, id);
+    return reference(beanType, id);
   }
 
   /**
@@ -660,14 +676,12 @@ public final class DB {
    * <ul>
    * <li>asc - ascending order (which is the default)</li>
    * <li>desc - Descending order</li>
-   * <li>nullsHigh - Treat null values as high/large values (which is the
-   * default)</li>
+   * <li>nullsHigh - Treat null values as high/large values (which is the default)</li>
    * <li>nullsLow- Treat null values as low/very small values</li>
    * </ul>
    * <p>
    * If you leave off any keywords the defaults are ascending order and treating
    * nulls as high values.
-   * </p>
    * <p>
    * Note that the sorting uses a Comparator and Collections.sort(); and does
    * not invoke a DB query.
@@ -1231,30 +1245,77 @@ public final class DB {
    * This will return null if the bean is not an enhanced entity bean.
    * </p>
    */
+  public static BeanState beanState(Object bean) {
+    return getDefault().beanState(bean);
+  }
+
+  /**
+   * Deprecated migrate to beanState().
+   */
+  @Deprecated
   public static BeanState getBeanState(Object bean) {
-    return getDefault().getBeanState(bean);
+    return beanState(bean);
   }
 
   /**
    * Return the value of the Id property for a given bean.
    */
+  public static Object beanId(Object bean) {
+    return getDefault().beanId(bean);
+  }
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
   public static Object getBeanId(Object bean) {
-    return getDefault().getBeanId(bean);
+    return beanId(bean);
+  }
+
+  /**
+   * Load and lock the bean using {@code select for update}.
+   * <p>
+   * This should be executed inside a transaction.
+   * <p>
+   * The bean needs to have an ID property set and can be a reference bean (only has ID)
+   * or partially or fully populated bean. This will load all the properties of the bean
+   * from the database using {@code select for update}.
+   *
+   * @param bean The entity bean that we wish to obtain a database lock on.
+   */
+  public static void lock(Object bean) {
+    getDefault().lock(bean);
+  }
+
+  /**
+   * Deprecated migrate to cacheManager().
+   */
+  @Deprecated
+  public static ServerCacheManager getServerCacheManager() {
+    return getDefault().cacheManager();
   }
 
   /**
    * Return the manager of the level 2 cache ("L2" cache).
    */
-  public static ServerCacheManager getServerCacheManager() {
-    return getDefault().getServerCacheManager();
+  public static ServerCacheManager cacheManager() {
+    return getDefault().cacheManager();
   }
 
   /**
    * Return the BackgroundExecutor service for asynchronous processing of
    * queries.
    */
+  public static BackgroundExecutor backgroundExecutor() {
+    return getDefault().backgroundExecutor();
+  }
+
+  /**
+   * Deprecated migrate to backgroundExecutor().
+   */
+  @Deprecated
   public static BackgroundExecutor getBackgroundExecutor() {
-    return getDefault().getBackgroundExecutor();
+    return backgroundExecutor();
   }
 
   /**
diff --git a/ebean-api/src/main/java/io/ebean/Database.java b/ebean-api/src/main/java/io/ebean/Database.java
index bd38253de..396f3225a 100644
--- a/ebean-api/src/main/java/io/ebean/Database.java
+++ b/ebean-api/src/main/java/io/ebean/Database.java
@@ -120,34 +120,82 @@ public interface Database {
   /**
    * Return AutoTune which is used to control the AutoTune service at runtime.
    */
-  AutoTune getAutoTune();
+  AutoTune autoTune();
+
+  /**
+   * Deprecated migrate to autoTune().
+   */
+  @Deprecated
+  default AutoTune getAutoTune() {
+    return autoTune();
+  }
 
   /**
    * Return the associated DataSource for this Database instance.
    */
-  DataSource getDataSource();
+  DataSource dataSource();
+
+  /**
+   * Deprecated migrate to dataSource().
+   */
+  @Deprecated
+  default DataSource getDataSource() {
+    return dataSource();
+  }
 
   /**
    * Return the associated read only DataSource for this Database instance (can be null).
    */
-  DataSource getReadOnlyDataSource();
+  DataSource readOnlyDataSource();
+
+  /**
+   * Deprecated migrate to readOnlyDataSource().
+   */
+  @Deprecated
+  default DataSource getReadOnlyDataSource() {
+    return readOnlyDataSource();
+  }
 
   /**
    * Return the name. This is used with {@link DB#byName(String)} to get a
    * Database that was registered with the DB singleton.
    */
-  String getName();
+  String name();
+
+  /**
+   * Deprecated migrate to name().
+   */
+  @Deprecated
+  default String getName() {
+    return name();
+  }
 
   /**
    * Return the ExpressionFactory for this database.
    */
-  ExpressionFactory getExpressionFactory();
+  ExpressionFactory expressionFactory();
+
+  /**
+   * Deprecated migrate to expressionFactory().
+   */
+  @Deprecated
+  default ExpressionFactory getExpressionFactory() {
+    return expressionFactory();
+  }
 
   /**
    * Return the MetaInfoManager which is used to get meta data from the Database
    * such as query execution statistics.
    */
-  MetaInfoManager getMetaInfoManager();
+  MetaInfoManager metaInfo();
+
+  /**
+   * Deprecated migrate to metaInfo().
+   */
+  @Deprecated
+  default MetaInfoManager getMetaInfoManager() {
+    return metaInfo();
+  }
 
   /**
    * Return the platform used for this database instance.
@@ -166,12 +214,28 @@ public interface Database {
    *
    * @return platform for this database instance
    */
-  Platform getPlatform();
+  Platform platform();
+
+  /**
+   * Deprecated migrate to platform().
+   */
+  @Deprecated
+  default Platform getPlatform() {
+    return platform();
+  }
 
   /**
    * Return the extended API intended for use by plugins.
    */
-  SpiServer getPluginApi();
+  SpiServer pluginApi();
+
+  /**
+   * Deprecated migrate to pluginApi().
+   */
+  @Deprecated
+  default SpiServer getPluginApi() {
+    return pluginApi();
+  }
 
   /**
    * Return the BeanState for a given entity bean.
@@ -179,12 +243,28 @@ public interface Database {
    * This will return null if the bean is not an enhanced entity bean.
    * </p>
    */
-  BeanState getBeanState(Object bean);
+  BeanState beanState(Object bean);
+
+  /**
+   * Deprecated migrate to beanState().
+   */
+  @Deprecated
+  default BeanState getBeanState(Object bean) {
+    return beanState(bean);
+  }
 
   /**
    * Return the value of the Id property for a given bean.
    */
-  Object getBeanId(Object bean);
+  Object beanId(Object bean);
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
+  default Object getBeanId(Object bean) {
+    return beanId(bean);
+  }
 
   /**
    * Set the Id value onto the bean converting the type of the id value if necessary.
@@ -196,7 +276,15 @@ public interface Database {
    * @param bean The entity bean to set the id value on.
    * @param id   The id value to set.
    */
-  Object setBeanId(Object bean, Object id);
+  Object beanId(Object bean, Object id);
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
+  default Object setBeanId(Object bean, Object id) {
+    return beanId(bean, id);
+  }
 
   /**
    * Return a map of the differences between two objects of the same type.
@@ -862,7 +950,15 @@ public interface Database {
    * @param id       the id value
    */
   @Nonnull
-  <T> T getReference(Class<T> beanType, Object id);
+  <T> T reference(Class<T> beanType, Object id);
+
+  /**
+   * Deprecated migrate to reference().
+   */
+  @Deprecated
+  default <T> T getReference(Class<T> beanType, Object id) {
+    return reference(beanType, id);
+  }
 
   /**
    * Return the extended API for Database.
@@ -1431,13 +1527,29 @@ public interface Database {
   /**
    * Return the manager of the server cache ("L2" cache).
    */
-  ServerCacheManager getServerCacheManager();
+  ServerCacheManager cacheManager();
+
+  /**
+   * Deprecated migrate to cacheManager().
+   */
+  @Deprecated
+  default ServerCacheManager getServerCacheManager() {
+    return cacheManager();
+  }
 
   /**
    * Return the BackgroundExecutor service for asynchronous processing of
    * queries.
    */
-  BackgroundExecutor getBackgroundExecutor();
+  BackgroundExecutor backgroundExecutor();
+
+  /**
+   * Deprecated migrate to backgroundExecutor().
+   */
+  @Deprecated
+  default BackgroundExecutor getBackgroundExecutor() {
+    return backgroundExecutor();
+  }
 
   /**
    * Return the JsonContext for reading/writing JSON.
@@ -1602,6 +1714,20 @@ public interface Database {
    */
   <T> Set<String> validateQuery(Query<T> query);
 
+  /**
+   * Load and lock the bean using {@code select for update}.
+   * <p>
+   * This should be executed inside a transaction and results in the bean being loaded or
+   * refreshed from the database and a database row lock held via {@code select for update}.
+   * <p>
+   * The bean needs to have an ID property set and can be a reference bean (only has ID)
+   * or partially or fully populated bean. This will load all the properties of the bean
+   * from the database using {@code select for update} obtaining a database row lock (using WAIT).
+   *
+   * @param bean The entity bean that we wish to obtain a database lock on.
+   */
+  void lock(Object bean);
+
   /**
    * Truncate all the given tables.
    */
diff --git a/ebean-api/src/main/java/io/ebean/DbContext.java b/ebean-api/src/main/java/io/ebean/DbContext.java
index 18df2169e..786cfd4bb 100644
--- a/ebean-api/src/main/java/io/ebean/DbContext.java
+++ b/ebean-api/src/main/java/io/ebean/DbContext.java
@@ -115,7 +115,7 @@ final class DbContext {
    * Register a server so we can get it by its name.
    */
   void register(Database server, boolean isDefault) {
-    registerWithName(server.getName(), server, isDefault);
+    registerWithName(server.name(), server, isDefault);
   }
 
   private void registerWithName(String name, Database server, boolean isDefault) {
diff --git a/ebean-api/src/main/java/io/ebean/Ebean.java b/ebean-api/src/main/java/io/ebean/Ebean.java
index fb0e34db3..eabc3c5b4 100644
--- a/ebean-api/src/main/java/io/ebean/Ebean.java
+++ b/ebean-api/src/main/java/io/ebean/Ebean.java
@@ -103,7 +103,7 @@ public final class Ebean {
    * </p>
    */
   public static ExpressionFactory getExpressionFactory() {
-    return getDefault().getExpressionFactory();
+    return getDefault().expressionFactory();
   }
 
   /**
@@ -642,7 +642,7 @@ public final class Ebean {
    * @param id       the id value
    */
   public static <T> T getReference(Class<T> beanType, Object id) {
-    return getDefault().getReference(beanType, id);
+    return getDefault().reference(beanType, id);
   }
 
   /**
@@ -1201,14 +1201,14 @@ public final class Ebean {
    * </p>
    */
   public static BeanState getBeanState(Object bean) {
-    return getDefault().getBeanState(bean);
+    return getDefault().beanState(bean);
   }
 
   /**
    * Return the manager of the server cache ("L2" cache).
    */
   public static ServerCacheManager getServerCacheManager() {
-    return getDefault().getServerCacheManager();
+    return getDefault().cacheManager();
   }
 
   /**
@@ -1216,7 +1216,7 @@ public final class Ebean {
    * queries.
    */
   public static BackgroundExecutor getBackgroundExecutor() {
-    return getDefault().getBackgroundExecutor();
+    return getDefault().backgroundExecutor();
   }
 
   /**
diff --git a/ebean-api/src/main/java/io/ebean/Expr.java b/ebean-api/src/main/java/io/ebean/Expr.java
index 01b8f0c49..1316f9873 100644
--- a/ebean-api/src/main/java/io/ebean/Expr.java
+++ b/ebean-api/src/main/java/io/ebean/Expr.java
@@ -16,7 +16,7 @@ import java.util.Map;
  * This provides a convenient way to create expressions for the default
  * database.
  * <p>
- * See also {@link DB#getExpressionFactory()}
+ * See also {@link DB#expressionFactory()}
  * </p>
  * <p>
  * Creates standard common expressions for using in a Query Where or Having
@@ -34,14 +34,14 @@ public class Expr {
    * Equal To - property equal to the given value.
    */
   public static Expression eq(String propertyName, Object value) {
-    return DB.getExpressionFactory().eq(propertyName, value);
+    return DB.expressionFactory().eq(propertyName, value);
   }
 
   /**
    * Not Equal To - property not equal to the given value.
    */
   public static Expression ne(String propertyName, Object value) {
-    return DB.getExpressionFactory().ne(propertyName, value);
+    return DB.expressionFactory().ne(propertyName, value);
   }
 
   /**
@@ -49,7 +49,7 @@ public class Expr {
    * using a lower() function to make it case insensitive).
    */
   public static Expression ieq(String propertyName, String value) {
-    return DB.getExpressionFactory().ieq(propertyName, value);
+    return DB.expressionFactory().ieq(propertyName, value);
   }
 
   /**
@@ -59,28 +59,28 @@ public class Expr {
    * </p>
    */
   public static Expression inRange(String propertyName, Object value1, Object value2) {
-    return DB.getExpressionFactory().inRange(propertyName, value1, value2);
+    return DB.expressionFactory().inRange(propertyName, value1, value2);
   }
 
   /**
    * Between - property between the two given values.
    */
   public static Expression between(String propertyName, Object value1, Object value2) {
-    return DB.getExpressionFactory().between(propertyName, value1, value2);
+    return DB.expressionFactory().between(propertyName, value1, value2);
   }
 
   /**
    * Between - value between two given properties.
    */
   public static Expression between(String lowProperty, String highProperty, Object value) {
-    return DB.getExpressionFactory().betweenProperties(lowProperty, highProperty, value);
+    return DB.expressionFactory().betweenProperties(lowProperty, highProperty, value);
   }
 
   /**
    * Greater Than - property greater than the given value.
    */
   public static Expression gt(String propertyName, Object value) {
-    return DB.getExpressionFactory().gt(propertyName, value);
+    return DB.expressionFactory().gt(propertyName, value);
   }
 
   /**
@@ -88,42 +88,42 @@ public class Expr {
    * value.
    */
   public static Expression ge(String propertyName, Object value) {
-    return DB.getExpressionFactory().ge(propertyName, value);
+    return DB.expressionFactory().ge(propertyName, value);
   }
 
   /**
    * Less Than - property less than the given value.
    */
   public static Expression lt(String propertyName, Object value) {
-    return DB.getExpressionFactory().lt(propertyName, value);
+    return DB.expressionFactory().lt(propertyName, value);
   }
 
   /**
    * Less Than or Equal to - property less than or equal to the given value.
    */
   public static Expression le(String propertyName, Object value) {
-    return DB.getExpressionFactory().le(propertyName, value);
+    return DB.expressionFactory().le(propertyName, value);
   }
 
   /**
    * Is Null - property is null.
    */
   public static Expression isNull(String propertyName) {
-    return DB.getExpressionFactory().isNull(propertyName);
+    return DB.expressionFactory().isNull(propertyName);
   }
 
   /**
    * Is Not Null - property is not null.
    */
   public static Expression isNotNull(String propertyName) {
-    return DB.getExpressionFactory().isNotNull(propertyName);
+    return DB.expressionFactory().isNotNull(propertyName);
   }
 
   /**
    * Case insensitive {@link #exampleLike(Object)}
    */
   public static ExampleExpression iexampleLike(Object example) {
-    return DB.getExpressionFactory().iexampleLike(example);
+    return DB.expressionFactory().iexampleLike(example);
   }
 
   /**
@@ -131,14 +131,14 @@ public class Expr {
    * LikeType.RAW (you need to add you own wildcards % and _).
    */
   public static ExampleExpression exampleLike(Object example) {
-    return DB.getExpressionFactory().exampleLike(example);
+    return DB.expressionFactory().exampleLike(example);
   }
 
   /**
    * Create the query by Example expression specifying more options.
    */
   public static ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType) {
-    return DB.getExpressionFactory().exampleLike(example, caseInsensitive, likeType);
+    return DB.expressionFactory().exampleLike(example, caseInsensitive, likeType);
   }
 
   /**
@@ -146,7 +146,7 @@ public class Expr {
    * characters % (percentage) and _ (underscore).
    */
   public static Expression like(String propertyName, String value) {
-    return DB.getExpressionFactory().like(propertyName, value);
+    return DB.expressionFactory().like(propertyName, value);
   }
 
   /**
@@ -155,14 +155,14 @@ public class Expr {
    * a lower() function to make the expression case insensitive.
    */
   public static Expression ilike(String propertyName, String value) {
-    return DB.getExpressionFactory().ilike(propertyName, value);
+    return DB.expressionFactory().ilike(propertyName, value);
   }
 
   /**
    * Starts With - property like value%.
    */
   public static Expression startsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().startsWith(propertyName, value);
+    return DB.expressionFactory().startsWith(propertyName, value);
   }
 
   /**
@@ -170,14 +170,14 @@ public class Expr {
    * lower() function to make the expression case insensitive.
    */
   public static Expression istartsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().istartsWith(propertyName, value);
+    return DB.expressionFactory().istartsWith(propertyName, value);
   }
 
   /**
    * Ends With - property like %value.
    */
   public static Expression endsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().endsWith(propertyName, value);
+    return DB.expressionFactory().endsWith(propertyName, value);
   }
 
   /**
@@ -185,14 +185,14 @@ public class Expr {
    * function to make the expression case insensitive.
    */
   public static Expression iendsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().iendsWith(propertyName, value);
+    return DB.expressionFactory().iendsWith(propertyName, value);
   }
 
   /**
    * Contains - property like %value%.
    */
   public static Expression contains(String propertyName, String value) {
-    return DB.getExpressionFactory().contains(propertyName, value);
+    return DB.expressionFactory().contains(propertyName, value);
   }
 
   /**
@@ -200,42 +200,42 @@ public class Expr {
    * function to make the expression case insensitive.
    */
   public static Expression icontains(String propertyName, String value) {
-    return DB.getExpressionFactory().icontains(propertyName, value);
+    return DB.expressionFactory().icontains(propertyName, value);
   }
 
   /**
    * For collection properties that are empty (have not existing elements).
    */
   public static Expression isEmpty(String propertyName) {
-    return DB.getExpressionFactory().isEmpty(propertyName);
+    return DB.expressionFactory().isEmpty(propertyName);
   }
 
   /**
    * For collection properties that are not empty (have existing elements).
    */
   public static Expression isNotEmpty(String propertyName) {
-    return DB.getExpressionFactory().isNotEmpty(propertyName);
+    return DB.expressionFactory().isNotEmpty(propertyName);
   }
 
   /**
    * In - property has a value in the array of values.
    */
   public static Expression in(String propertyName, Object[] values) {
-    return DB.getExpressionFactory().in(propertyName, values);
+    return DB.expressionFactory().in(propertyName, values);
   }
 
   /**
    * In - using a subQuery.
    */
   public static Expression in(String propertyName, Query<?> subQuery) {
-    return DB.getExpressionFactory().in(propertyName, subQuery);
+    return DB.expressionFactory().in(propertyName, subQuery);
   }
 
   /**
    * In - property has a value in the collection of values.
    */
   public static Expression in(String propertyName, Collection<?> values) {
-    return DB.getExpressionFactory().in(propertyName, values);
+    return DB.expressionFactory().in(propertyName, values);
   }
 
   /**
@@ -272,14 +272,14 @@ public class Expr {
    * }</pre>
    */
   public static Expression inOrEmpty(String propertyName, Collection<?> values) {
-    return DB.getExpressionFactory().inOrEmpty(propertyName, values);
+    return DB.expressionFactory().inOrEmpty(propertyName, values);
   }
 
   /**
    * Id Equal to - ID property is equal to the value.
    */
   public static Expression idEq(Object value) {
-    return DB.getExpressionFactory().idEq(value);
+    return DB.expressionFactory().idEq(value);
   }
 
   /**
@@ -292,7 +292,7 @@ public class Expr {
    * @param propertyMap a map keyed by property names.
    */
   public static Expression allEq(Map<String, Object> propertyMap) {
-    return DB.getExpressionFactory().allEq(propertyMap);
+    return DB.expressionFactory().allEq(propertyMap);
   }
 
   /**
@@ -303,7 +303,7 @@ public class Expr {
    * </p>
    */
   public static Expression raw(String raw, Object value) {
-    return DB.getExpressionFactory().raw(raw, value);
+    return DB.expressionFactory().raw(raw, value);
   }
 
   /**
@@ -314,53 +314,48 @@ public class Expr {
    * </p>
    */
   public static Expression raw(String raw, Object[] values) {
-    return DB.getExpressionFactory().raw(raw, values);
+    return DB.expressionFactory().raw(raw, values);
   }
 
   /**
    * Add raw expression with no parameters.
    */
   public static Expression raw(String raw) {
-    return DB.getExpressionFactory().raw(raw);
+    return DB.expressionFactory().raw(raw);
   }
 
   /**
    * And - join two expressions with a logical and.
    */
   public static Expression and(Expression expOne, Expression expTwo) {
-
-    return DB.getExpressionFactory().and(expOne, expTwo);
+    return DB.expressionFactory().and(expOne, expTwo);
   }
 
   /**
    * Or - join two expressions with a logical or.
    */
   public static Expression or(Expression expOne, Expression expTwo) {
-
-    return DB.getExpressionFactory().or(expOne, expTwo);
+    return DB.expressionFactory().or(expOne, expTwo);
   }
 
   /**
    * Negate the expression (prefix it with NOT).
    */
   public static Expression not(Expression exp) {
-
-    return DB.getExpressionFactory().not(exp);
+    return DB.expressionFactory().not(exp);
   }
 
   /**
    * Return a list of expressions that will be joined by AND's.
    */
   public static <T> Junction<T> conjunction(Query<T> query) {
-
-    return DB.getExpressionFactory().conjunction(query);
+    return DB.expressionFactory().conjunction(query);
   }
 
   /**
    * Return a list of expressions that will be joined by OR's.
    */
   public static <T> Junction<T> disjunction(Query<T> query) {
-
-    return DB.getExpressionFactory().disjunction(query);
+    return DB.expressionFactory().disjunction(query);
   }
 }
diff --git a/ebean-api/src/main/java/io/ebean/Finder.java b/ebean-api/src/main/java/io/ebean/Finder.java
index 3c9318e7d..cc5ef87f6 100644
--- a/ebean-api/src/main/java/io/ebean/Finder.java
+++ b/ebean-api/src/main/java/io/ebean/Finder.java
@@ -137,11 +137,11 @@ public class Finder<I, T> {
   /**
    * Creates an entity reference for this ID.
    * <p>
-   * Equivalent to {@link Database#getReference(Class, Object)}
+   * Equivalent to {@link Database#reference(Class, Object)}
    */
   @Nonnull
   public T ref(I id) {
-    return db().getReference(type, id);
+    return db().reference(type, id);
   }
 
   /**
diff --git a/ebean-api/src/main/java/io/ebean/Transaction.java b/ebean-api/src/main/java/io/ebean/Transaction.java
index 0856a6e4e..06f6bd315 100644
--- a/ebean-api/src/main/java/io/ebean/Transaction.java
+++ b/ebean-api/src/main/java/io/ebean/Transaction.java
@@ -538,7 +538,15 @@ public interface Transaction extends AutoCloseable {
    * Examples of when a developer may wish to use the connection directly are:
    * Savepoints, advanced CLOB BLOB use and advanced stored procedure calls.
    */
-  Connection getConnection();
+  Connection connection();
+
+  /**
+   * Deprecated migrate to connection().
+   */
+  @Deprecated
+  default Connection getConnection() {
+    return connection();
+  }
 
   /**
    * Add table modification information to the TransactionEvent.
diff --git a/ebean-api/src/main/java/io/ebean/bean/BeanCollectionLoader.java b/ebean-api/src/main/java/io/ebean/bean/BeanCollectionLoader.java
index 2f0e2848d..b7dc32034 100644
--- a/ebean-api/src/main/java/io/ebean/bean/BeanCollectionLoader.java
+++ b/ebean-api/src/main/java/io/ebean/bean/BeanCollectionLoader.java
@@ -11,7 +11,7 @@ public interface BeanCollectionLoader {
   /**
    * Return the name of the associated Database.
    */
-  String getName();
+  String name();
 
   /**
    * Invoke the lazy loading for this bean collection.
diff --git a/ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java b/ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java
index 9924bf4f7..3725cc73c 100644
--- a/ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java
+++ b/ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java
@@ -843,7 +843,7 @@ public final class EntityBeanIntercept implements Serializable {
         }
         // For stand alone reference bean or after deserialisation lazy load
         // using the ebeanServer. Synchronise only on the bean.
-        loadBeanInternal(loadProperty, database.getPluginApi().beanLoader());
+        loadBeanInternal(loadProperty, database.pluginApi().beanLoader());
         return;
       }
     } finally {
diff --git a/ebean-api/src/main/java/io/ebean/bean/SingleBeanLoader.java b/ebean-api/src/main/java/io/ebean/bean/SingleBeanLoader.java
index ad4a30b95..73f3fe5d8 100644
--- a/ebean-api/src/main/java/io/ebean/bean/SingleBeanLoader.java
+++ b/ebean-api/src/main/java/io/ebean/bean/SingleBeanLoader.java
@@ -20,7 +20,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
   @Override
   public String getName() {
-    return database.getName();
+    return database.name();
   }
 
   @Override
@@ -39,7 +39,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
     @Override
     public void loadBean(EntityBeanIntercept ebi) {
-      database.getPluginApi().loadBeanL2(ebi);
+      database.pluginApi().loadBeanL2(ebi);
     }
   }
 
@@ -53,7 +53,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
     @Override
     public void loadBean(EntityBeanIntercept ebi) {
-      database.getPluginApi().loadBeanRef(ebi);
+      database.pluginApi().loadBeanRef(ebi);
     }
   }
 
@@ -67,7 +67,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
     @Override
     public void loadBean(EntityBeanIntercept ebi) {
-      database.getPluginApi().loadBean(ebi);
+      database.pluginApi().loadBean(ebi);
     }
   }
 }
diff --git a/ebean-api/src/main/java/io/ebean/cache/QueryCacheEntry.java b/ebean-api/src/main/java/io/ebean/cache/QueryCacheEntry.java
index 31f1134d9..9c07e3574 100644
--- a/ebean-api/src/main/java/io/ebean/cache/QueryCacheEntry.java
+++ b/ebean-api/src/main/java/io/ebean/cache/QueryCacheEntry.java
@@ -13,9 +13,7 @@ import java.util.Set;
 public class QueryCacheEntry {
 
   private final Object value;
-
   private final Set<String> dependentTables;
-
   private final long timestamp;
 
   /**
diff --git a/ebean-api/src/main/java/io/ebean/cache/ServerCache.java b/ebean-api/src/main/java/io/ebean/cache/ServerCache.java
index 82bd452b0..1476e567d 100644
--- a/ebean-api/src/main/java/io/ebean/cache/ServerCache.java
+++ b/ebean-api/src/main/java/io/ebean/cache/ServerCache.java
@@ -10,17 +10,17 @@ import java.util.Set;
  * Represents part of the "L2" server side cache.
  * <p>
  * This is used to cache beans or query results (bean collections).
- * </p>
  * <p>
  * There are 2 ServerCache's for each bean type. One is used as the 'bean cache'
  * which holds beans of a given type. The other is the 'query cache' holding
  * query results for a given type.
- * </p>
  */
 public interface ServerCache {
 
+  /**
+   * Get values for many keys.
+   */
   default Map<Object, Object> getAll(Set<Object> keys) {
-
     Map<Object, Object> map = new LinkedHashMap<>();
     for (Object key : keys) {
       Object value = get(key);
@@ -73,6 +73,14 @@ public interface ServerCache {
   /**
    * Return the hit ratio the cache is currently getting.
    */
+  default int hitRatio() {
+    return getHitRatio();
+  }
+
+  /**
+   * Deprecated migrate to hitRatio().
+   */
+  @Deprecated
   int getHitRatio();
 
   /**
@@ -80,6 +88,14 @@ public interface ServerCache {
    *
    * @param reset if true the statistics are reset.
    */
+  default ServerCacheStatistics statistics(boolean reset) {
+    return getStatistics(reset);
+  }
+
+  /**
+   * Deprecated migrate to statistics().
+   */
+  @Deprecated
   ServerCacheStatistics getStatistics(boolean reset);
 
   /**
diff --git a/ebean-api/src/main/java/io/ebean/cache/ServerCacheManager.java b/ebean-api/src/main/java/io/ebean/cache/ServerCacheManager.java
index 5cc1a6040..67156a642 100644
--- a/ebean-api/src/main/java/io/ebean/cache/ServerCacheManager.java
+++ b/ebean-api/src/main/java/io/ebean/cache/ServerCacheManager.java
@@ -21,7 +21,15 @@ public interface ServerCacheManager {
    * rather than background processing.
    * </p>
    */
-  boolean isLocalL2Caching();
+  boolean localL2Caching();
+
+  /**
+   * Deprecated migrate to localL2Caching().
+   */
+  @Deprecated
+  default boolean isLocalL2Caching() {
+    return localL2Caching();
+  }
 
   /**
    * Return all the cache regions.
@@ -36,37 +44,78 @@ public interface ServerCacheManager {
    *
    * @param regions A region name or comma delimited list of region names.
    */
-  void setEnabledRegions(String regions);
+  void enabledRegions(String regions);
+
+  /**
+   * Deprecated migrate to enabledRegions().
+   */
+  @Deprecated
+  default void setEnabledRegions(String regions) {
+    enabledRegions(regions);
+  }
 
   /**
    * Enable or disable all the cache regions.
    */
-  void setAllRegionsEnabled(boolean enabled);
+  void allRegionsEnabled(boolean enabled);
 
   /**
-   * Return the cache region by name. Typically to enable or disable the region.
+   * Deprecated migrate to allRegionsEnabled().
    */
-  ServerCacheRegion getRegion(String name);
+  @Deprecated
+  default void setAllRegionsEnabled(boolean enabled) {
+    allRegionsEnabled(enabled);
+  }
+
+  /**
+   * Return the cache region by name. Typically, to enable or disable the region.
+   */
+  ServerCacheRegion region(String name);
+
+  @Deprecated
+  default ServerCacheRegion getRegion(String name) {
+    return region(name);
+  }
 
   /**
    * Return the cache for mapping natural keys to id values.
    */
-  ServerCache getNaturalKeyCache(Class<?> beanType);
+  ServerCache naturalKeyCache(Class<?> beanType);
+
+  @Deprecated
+  default ServerCache getNaturalKeyCache(Class<?> beanType) {
+    return naturalKeyCache(beanType);
+  }
 
   /**
    * Return the cache for beans of a particular type.
    */
-  ServerCache getBeanCache(Class<?> beanType);
+  ServerCache beanCache(Class<?> beanType);
+
+  @Deprecated
+  default ServerCache getBeanCache(Class<?> beanType) {
+    return beanCache(beanType);
+  }
 
   /**
    * Return the cache for associated many properties of a bean type.
    */
-  ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName);
+  ServerCache collectionIdsCache(Class<?> beanType, String propertyName);
+
+  @Deprecated
+  default ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName) {
+    return collectionIdsCache(beanType, propertyName);
+  }
 
   /**
    * Return the cache for query results of a particular type of bean.
    */
-  ServerCache getQueryCache(Class<?> beanType);
+  ServerCache queryCache(Class<?> beanType);
+
+  @Deprecated
+  default ServerCache getQueryCache(Class<?> beanType) {
+    return queryCache(beanType);
+  }
 
   /**
    * This clears both the bean and query cache for a given type.
diff --git a/ebean-api/src/main/java/io/ebean/cache/ServerCacheOptions.java b/ebean-api/src/main/java/io/ebean/cache/ServerCacheOptions.java
index fe8fdb486..c455286ea 100644
--- a/ebean-api/src/main/java/io/ebean/cache/ServerCacheOptions.java
+++ b/ebean-api/src/main/java/io/ebean/cache/ServerCacheOptions.java
@@ -18,7 +18,6 @@ public class ServerCacheOptions {
    * Construct with no set options.
    */
   public ServerCacheOptions() {
-
   }
 
   /**
@@ -73,7 +72,6 @@ public class ServerCacheOptions {
    * Return a copy of this object.
    */
   public ServerCacheOptions copy() {
-
     ServerCacheOptions copy = new ServerCacheOptions();
     copy.maxSize = maxSize;
     copy.maxIdleSecs = maxIdleSecs;
diff --git a/ebean-api/src/main/java/io/ebean/cache/ServerCacheRegion.java b/ebean-api/src/main/java/io/ebean/cache/ServerCacheRegion.java
index b63668d91..c798b5a35 100644
--- a/ebean-api/src/main/java/io/ebean/cache/ServerCacheRegion.java
+++ b/ebean-api/src/main/java/io/ebean/cache/ServerCacheRegion.java
@@ -8,7 +8,15 @@ public interface ServerCacheRegion {
   /**
    * Return the region name.
    */
-  String getName();
+  String name();
+
+  /**
+   * Deprecated migrate to name().
+   */
+  @Deprecated
+  default String getName() {
+    return name();
+  }
 
   /**
    * Return true if the cache region is enabled.
diff --git a/ebean-api/src/main/java/io/ebean/common/AbstractBeanCollection.java b/ebean-api/src/main/java/io/ebean/common/AbstractBeanCollection.java
index 809ca13b3..912d9582f 100644
--- a/ebean-api/src/main/java/io/ebean/common/AbstractBeanCollection.java
+++ b/ebean-api/src/main/java/io/ebean/common/AbstractBeanCollection.java
@@ -63,7 +63,7 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
    */
   AbstractBeanCollection(BeanCollectionLoader loader, EntityBean ownerBean, String propertyName) {
     this.loader = loader;
-    this.ebeanServerName = loader.getName();
+    this.ebeanServerName = loader.name();
     this.ownerBean = ownerBean;
     this.propertyName = propertyName;
     this.readOnly = ownerBean != null && ownerBean._ebean_getIntercept().isReadOnly();
@@ -111,7 +111,7 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
   public void setLoader(BeanCollectionLoader loader) {
     this.registeredWithLoadContext = true;
     this.loader = loader;
-    this.ebeanServerName = loader.getName();
+    this.ebeanServerName = loader.name();
   }
 
   @Override
diff --git a/ebean-api/src/main/java/io/ebean/config/dbplatform/SimpleSequenceIdGenerator.java b/ebean-api/src/main/java/io/ebean/config/dbplatform/SimpleSequenceIdGenerator.java
index 95ee33894..e028aaa3a 100644
--- a/ebean-api/src/main/java/io/ebean/config/dbplatform/SimpleSequenceIdGenerator.java
+++ b/ebean-api/src/main/java/io/ebean/config/dbplatform/SimpleSequenceIdGenerator.java
@@ -61,7 +61,7 @@ public class SimpleSequenceIdGenerator implements PlatformIdGenerator {
     PreparedStatement pstmt = null;
     ResultSet rset = null;
     try {
-      c = useTxnConnection ? t.getConnection() : dataSource.getConnection();
+      c = useTxnConnection ? t.connection() : dataSource.getConnection();
       pstmt = c.prepareStatement(sql);
       rset = pstmt.executeQuery();
       if (rset.next()) {
diff --git a/ebean-api/src/main/java/io/ebean/event/BeanDeleteIdRequest.java b/ebean-api/src/main/java/io/ebean/event/BeanDeleteIdRequest.java
index 795886830..66831b69e 100644
--- a/ebean-api/src/main/java/io/ebean/event/BeanDeleteIdRequest.java
+++ b/ebean-api/src/main/java/io/ebean/event/BeanDeleteIdRequest.java
@@ -1,5 +1,6 @@
 package io.ebean.event;
 
+import io.ebean.Database;
 import io.ebean.EbeanServer;
 import io.ebean.Transaction;
 
@@ -9,18 +10,62 @@ import io.ebean.Transaction;
 public interface BeanDeleteIdRequest {
 
   /**
-   * Return the server processing the request.
+   * Deprecated migrate to database().
    */
+  @Deprecated
   EbeanServer getEbeanServer();
 
+  /**
+   * Deprecated migrate to database().
+   */
+  @Deprecated
+  default Database getDatabase() {
+    return getEbeanServer();
+  }
+
+  /**
+   * Return the DB processing the request.
+   */
+  default Database database() {
+    return getEbeanServer();
+  }
+
   /**
    * Return the Transaction associated with this request.
    */
-  Transaction getTransaction();
+  Transaction transaction();
+
+  /**
+   * Deprecated migrate to transaction().
+   */
+  @Deprecated
+  default Transaction getTransaction() {
+    return transaction();
+  }
+
+  /**
+   * Returns the bean type of the bean being deleted.
+   */
+  Class<?> beanType();
+
+  /**
+   * Deprecated migrate to beanType().
+   */
+  @Deprecated
+  default Class<?> getBeanType() {
+    return beanType();
+  }
 
   /**
    * Returns the Id value of the bean being deleted.
    */
-  Object getId();
+  Object id();
 
+  /**
+   * Deprecated migrate to id().
+   */
+  @Deprecated
+  default Object getId() {
+    return id();
+  }
 }
diff --git a/ebean-api/src/main/java/io/ebean/event/BeanPersistRequest.java b/ebean-api/src/main/java/io/ebean/event/BeanPersistRequest.java
index c5043fb74..57930a107 100644
--- a/ebean-api/src/main/java/io/ebean/event/BeanPersistRequest.java
+++ b/ebean-api/src/main/java/io/ebean/event/BeanPersistRequest.java
@@ -1,5 +1,6 @@
 package io.ebean.event;
 
+import io.ebean.Database;
 import io.ebean.EbeanServer;
 import io.ebean.Transaction;
 import io.ebean.ValuePair;
@@ -17,20 +18,44 @@ import java.util.Set;
 public interface BeanPersistRequest<T> {
 
   /**
-   * Return the server processing the request.
+   * Return the DB processing the request.
    */
+  default Database database() {
+    return getEbeanServer();
+  }
+
+  /**
+   * Deprecated migrate to database().
+   */
+  @Deprecated
   EbeanServer getEbeanServer();
 
   /**
    * Return the Transaction associated with this request.
    */
-  Transaction getTransaction();
+  Transaction transaction();
+
+  /**
+   * Deprecated migrate to transaction().
+   */
+  @Deprecated
+  default Transaction getTransaction() {
+    return transaction();
+  }
 
   /**
    * For an update or delete of a partially populated bean this is the set of
    * loaded properties and otherwise returns null.
    */
-  Set<String> getLoadedProperties();
+  Set<String> loadedProperties();
+
+  /**
+   * Deprecated migrate to loadedProperties().
+   */
+  @Deprecated
+  default Set<String> getLoadedProperties() {
+    return loadedProperties();
+  }
 
   /**
    * For an update this is the set of properties that where updated.
@@ -39,12 +64,28 @@ public interface BeanPersistRequest<T> {
    * should be preferred if it satisfies the requirement.
    * </p>
    */
-  Set<String> getUpdatedProperties();
+  Set<String> updatedProperties();
+
+  /**
+   * Deprecated migrate to updatedProperties().
+   */
+  @Deprecated
+  default Set<String> getUpdatedProperties() {
+    return updatedProperties();
+  }
 
   /**
    * Flags set for dirty properties (used by ElasticSearch integration).
    */
-  boolean[] getDirtyProperties();
+  boolean[] dirtyProperties();
+
+  /**
+   * Deprecated migrate to updatedProperties().
+   */
+  @Deprecated
+  default boolean[] getDirtyProperties() {
+    return dirtyProperties();
+  }
 
   /**
    * Return true for an update request if at least one of dirty properties is contained
@@ -66,11 +107,27 @@ public interface BeanPersistRequest<T> {
   /**
    * Returns the bean being inserted updated or deleted.
    */
-  T getBean();
+  T bean();
+
+  /**
+   * Deprecated migrate to bean().
+   */
+  @Deprecated
+  default T getBean() {
+    return bean();
+  }
 
   /**
    * Returns a map of the properties that have changed and their new and old values.
    */
-  Map<String, ValuePair> getUpdatedValues();
+  Map<String, ValuePair> updatedValues();
+
+  /**
+   * Deprecated migrate to updatedValues().
+   */
+  @Deprecated
+  default Map<String, ValuePair> getUpdatedValues() {
+    return updatedValues();
+  }
 
 }
diff --git a/ebean-api/src/main/java/io/ebean/event/BeanQueryRequest.java b/ebean-api/src/main/java/io/ebean/event/BeanQueryRequest.java
index 4c13aee54..a8f2b7a29 100644
--- a/ebean-api/src/main/java/io/ebean/event/BeanQueryRequest.java
+++ b/ebean-api/src/main/java/io/ebean/event/BeanQueryRequest.java
@@ -1,5 +1,6 @@
 package io.ebean.event;
 
+import io.ebean.Database;
 import io.ebean.EbeanServer;
 import io.ebean.Query;
 import io.ebean.Transaction;
@@ -10,19 +11,43 @@ import io.ebean.Transaction;
 public interface BeanQueryRequest<T> {
 
   /**
-   * Return the server processing the request.
+   * Return the DB processing the request.
    */
+  default Database database() {
+    return getEbeanServer();
+  }
+
+  /**
+   * Deprecated migrate to database().
+   */
+  @Deprecated
   EbeanServer getEbeanServer();
 
   /**
    * Return the Transaction associated with this request.
    */
-  Transaction getTransaction();
+  Transaction transaction();
+
+  /**
+   * Deprecated migrate to transaction().
+   */
+  @Deprecated
+  default Transaction getTransaction() {
+    return transaction();
+  }
 
   /**
    * Returns the query.
    */
-  Query<T> getQuery();
+  Query<T> query();
+
+  /**
+   * Deprecated migrate to query().
+   */
+  @Deprecated
+  default Query<T> getQuery() {
+    return query();
+  }
 
   /**
    * Return true if an Id IN expression should have the bind parameters padded.
diff --git a/ebean-api/src/main/java/io/ebean/event/BulkTableEvent.java b/ebean-api/src/main/java/io/ebean/event/BulkTableEvent.java
index a10168cf5..d37743303 100644
--- a/ebean-api/src/main/java/io/ebean/event/BulkTableEvent.java
+++ b/ebean-api/src/main/java/io/ebean/event/BulkTableEvent.java
@@ -8,7 +8,15 @@ public interface BulkTableEvent {
   /**
    * Return the name of the table that was involved.
    */
-  String getTableName();
+  String tableName();
+
+  /**
+   * Deprecated migrate to tableName().
+   */
+  @Deprecated
+  default String getTableName() {
+    return tableName();
+  }
 
   /**
    * Return true if rows were inserted.
diff --git a/ebean-api/src/main/java/io/ebean/metric/QueryPlanMetric.java b/ebean-api/src/main/java/io/ebean/metric/QueryPlanMetric.java
index edc2aaf03..07a9ca6d2 100644
--- a/ebean-api/src/main/java/io/ebean/metric/QueryPlanMetric.java
+++ b/ebean-api/src/main/java/io/ebean/metric/QueryPlanMetric.java
@@ -10,7 +10,15 @@ public interface QueryPlanMetric {
   /**
    * Return the underlying timed metric.
    */
-  TimedMetric getMetric();
+  TimedMetric metric();
+
+  /**
+   * Deprecated migrate to metric().
+   */
+  @Deprecated
+  default TimedMetric getMetric() {
+    return metric();
+  }
 
   /**
    * Visit the underlying metric.
diff --git a/ebean-api/src/main/java/io/ebean/plugin/BeanDocType.java b/ebean-api/src/main/java/io/ebean/plugin/BeanDocType.java
index 92b3d6d19..77a8f72d9 100644
--- a/ebean-api/src/main/java/io/ebean/plugin/BeanDocType.java
+++ b/ebean-api/src/main/java/io/ebean/plugin/BeanDocType.java
@@ -16,11 +16,27 @@ public interface BeanDocType<T> {
   /**
    * Return the doc store index type for this bean type.
    */
+  default String indexType() {
+    return getIndexType();
+  }
+
+  /**
+   * Deprecated migrate to indexType().
+   */
+  @Deprecated
   String getIndexType();
 
   /**
    * Return the doc store index name for this bean type.
    */
+  default String indexName() {
+    return getIndexName();
+  }
+
+  /**
+   * Deprecated migrate to indexName().
+   */
+  @Deprecated
   String getIndexName();
 
   /**
@@ -32,12 +48,28 @@ public interface BeanDocType<T> {
   /**
    * Return the FetchPath for the embedded document.
    */
+  default FetchPath embedded(String path) {
+    return getEmbedded(path);
+  }
+
+  /**
+   * Deprecated migrate to embedded().
+   */
+  @Deprecated
   FetchPath getEmbedded(String path);
 
   /**
    * For embedded 'many' properties we need a FetchPath relative to the root which is used to
    * build and replace the embedded list.
    */
+  default FetchPath embeddedManyRoot(String path) {
+    return getEmbeddedManyRoot(path);
+  }
+
+  /**
+   * Deprecated migrate to embeddedManyRoot().
+   */
+  @Deprecated
   FetchPath getEmbeddedManyRoot(String path);
 
   /**
diff --git a/ebean-api/src/main/java/io/ebean/plugin/BeanType.java b/ebean-api/src/main/java/io/ebean/plugin/BeanType.java
index e44474cd3..661b370d2 100644
--- a/ebean-api/src/main/java/io/ebean/plugin/BeanType.java
+++ b/ebean-api/src/main/java/io/ebean/plugin/BeanType.java
@@ -22,24 +22,56 @@ public interface BeanType<T> {
    * Return the short name of the bean type.
    */
   @Nonnull
-  String getName();
+  String name();
+
+  /**
+   * Deprecated migrate to name().
+   */
+  @Deprecated
+  default String getName() {
+    return name();
+  }
 
   /**
    * Return the full name of the bean type.
    */
   @Nonnull
-  String getFullName();
+  String fullName();
+
+  /**
+   * Deprecated migrate to fullName().
+   */
+  @Deprecated
+  default String getFullName() {
+    return fullName();
+  }
 
   /**
    * Return the class type this BeanDescriptor describes.
    */
   @Nonnull
-  Class<T> getBeanType();
+  Class<T> type();
+
+  /**
+   * Deprecated migrate to type().
+   */
+  @Deprecated
+  default Class<T> getBeanType() {
+    return type();
+  }
 
   /**
    * Return the type bean for an OneToMany or ManyToOne or ManyToMany property.
    */
-  BeanType<?> getBeanTypeAtPath(String propertyName);
+  BeanType<?> beanTypeAtPath(String propertyName);
+
+  /**
+   * Deprecated migrate to beanTypeAtPath().
+   */
+  @Deprecated
+  default BeanType<?> getBeanTypeAtPath(String propertyName) {
+    return beanTypeAtPath(propertyName);
+  }
 
   /**
    * Return all the properties for this bean type.
@@ -50,22 +82,54 @@ public interface BeanType<T> {
   /**
    * Return the Id property.
    */
-  Property getIdProperty();
+  Property idProperty();
+
+  /**
+   * Deprecated migrate to idProperty().
+   */
+  @Deprecated
+  default Property getIdProperty() {
+    return idProperty();
+  }
 
   /**
    * Return the when modified property if there is one defined.
    */
-  Property getWhenModifiedProperty();
+  Property whenModifiedProperty();
+
+  /**
+   * Deprecated migrate to idProperty().
+   */
+  @Deprecated
+  default Property getWhenModifiedProperty() {
+    return whenModifiedProperty();
+  }
 
   /**
    * Return the when created property if there is one defined.
    */
-  Property getWhenCreatedProperty();
+  Property whenCreatedProperty();
+
+  /**
+   * Deprecated migrate to idProperty().
+   */
+  @Deprecated
+  default Property getWhenCreatedProperty() {
+    return whenCreatedProperty();
+  }
 
   /**
    * Return the Property to read values from a bean.
    */
-  Property getProperty(String propertyName);
+  Property property(String propertyName);
+
+  /**
+   * Deprecated migrate to property().
+   */
+  @Deprecated
+  default Property getProperty(String propertyName) {
+    return property(propertyName);
+  }
 
   /**
    * Return the ExpressionPath for a given property path.
@@ -73,7 +137,15 @@ public interface BeanType<T> {
    * This can return a property or nested property path.
    * </p>
    */
-  ExpressionPath getExpressionPath(String path);
+  ExpressionPath expressionPath(String path);
+
+  /**
+   * Deprecated migrate to expressionPath().
+   */
+  @Deprecated
+  default ExpressionPath getExpressionPath(String path) {
+    return expressionPath(path);
+  }
 
   /**
    * Return true if the property is a valid known property or path for the given bean type.
@@ -108,7 +180,15 @@ public interface BeanType<T> {
   /**
    * Return the base table this bean type maps to.
    */
-  String getBaseTable();
+  String baseTable();
+
+  /**
+   * Deprecated migrate to baseTable().
+   */
+  @Deprecated
+  default String getBaseTable() {
+    return baseTable();
+  }
 
   /**
    * Create a new instance of the bean.
@@ -118,42 +198,99 @@ public interface BeanType<T> {
   /**
    * Return the bean id. This is the same as getBeanId() but without the generic type.
    */
-  Object beanId(Object bean);
+  Object id(Object bean);
 
   /**
-   * Return the id value for the given bean.
+   * Deprecated migrate to id()
    */
+  @Deprecated
+  default Object beanId(Object bean) {
+    return id(bean);
+  }
+
+  /**
+   * Deprecated migrate to id()
+   */
+  @Deprecated
   Object getBeanId(T bean);
 
   /**
    * Set the id value to the bean.
    */
-  void setBeanId(T bean, Object idValue);
+  void setId(T bean, Object idValue);
+
+  /**
+   * Deprecated migrate to setId()
+   */
+  @Deprecated
+  default void setBeanId(T bean, Object idValue) {
+    setId(bean, idValue);
+  }
 
   /**
    * Return the bean persist controller.
    */
-  BeanPersistController getPersistController();
+  BeanPersistController persistController();
+
+  /**
+   * Deprecated migrate to persistController()
+   */
+  @Deprecated
+  default BeanPersistController getPersistController() {
+    return persistController();
+  }
 
   /**
    * Return the bean persist listener.
    */
-  BeanPersistListener getPersistListener();
+  BeanPersistListener persistListener();
+
+  /**
+   * Deprecated migrate to persistListener()
+   */
+  @Deprecated
+  default BeanPersistListener getPersistListener() {
+    return persistListener();
+  }
 
   /**
    * Return the beanFinder. Usually null unless overriding the finder.
    */
-  BeanFindController getFindController();
+  BeanFindController findController();
+
+  /**
+   * Deprecated migrate to findController()
+   */
+  @Deprecated
+  default BeanFindController getFindController() {
+    return findController();
+  }
 
   /**
    * Return the BeanQueryAdapter or null if none is defined.
    */
-  BeanQueryAdapter getQueryAdapter();
+  BeanQueryAdapter queryAdapter();
+
+  /**
+   * Deprecated migrate to queryAdapter()
+   */
+  @Deprecated
+  default BeanQueryAdapter getQueryAdapter() {
+    return queryAdapter();
+  }
 
   /**
    * Return the identity generation type.
    */
-  IdType getIdType();
+  IdType idType();
+
+  /**
+   * Deprecated migrate to idType()
+   */
+  @Deprecated
+  default IdType getIdType() {
+    return idType();
+  }
 
   /**
    * Return true if this bean type has doc store backing.
@@ -167,12 +304,28 @@ public interface BeanType<T> {
    * for the document store.
    * </p>
    */
-  DocMapping getDocMapping();
+  DocMapping docMapping();
+
+  /**
+   * Deprecated migrate to docMapping()
+   */
+  @Deprecated
+  default DocMapping getDocMapping() {
+    return docMapping();
+  }
 
   /**
    * Return the doc store queueId for this bean type.
    */
-  String getDocStoreQueueId();
+  String docStoreQueueId();
+
+  /**
+   * Deprecated migrate to docStoreQueueId()
+   */
+  @Deprecated
+  default String getDocStoreQueueId() {
+    return docStoreQueueId();
+  }
 
   /**
    * Return the doc store support for this bean type.\
@@ -203,12 +356,28 @@ public interface BeanType<T> {
   /**
    * Returns all direct children of this beantype
    */
-  List<BeanType<?>> getInheritanceChildren();
+  List<BeanType<?>> inheritanceChildren();
 
   /**
-   * Returns the parent in inheritance hiearchy
+   * Deprecated migrate to inheritanceChildren()
    */
-  BeanType<?> getInheritanceParent();
+  @Deprecated
+  default List<BeanType<?>> getInheritanceChildren() {
+    return inheritanceChildren();
+  }
+
+  /**
+   * Returns the parent in inheritance hierarchy
+   */
+  BeanType<?> inheritanceParent();
+
+  /**
+   * Deprecated migrate to inheritanceParent()
+   */
+  @Deprecated
+  default BeanType<?> getInheritanceParent() {
+    return inheritanceParent();
+  }
 
   /**
    * Visit all children recursively
@@ -218,7 +387,15 @@ public interface BeanType<T> {
   /**
    * Return the discriminator column.
    */
-  String getDiscColumn();
+  String discColumn();
+
+  /**
+   * Deprecated migrate to discColumn()
+   */
+  @Deprecated
+  default String getDiscColumn() {
+    return discColumn();
+  }
 
   /**
    * Create a bean given the discriminator value.
diff --git a/ebean-api/src/main/java/io/ebean/plugin/ExpressionPath.java b/ebean-api/src/main/java/io/ebean/plugin/ExpressionPath.java
index 45de4c66b..b7675f87b 100644
--- a/ebean-api/src/main/java/io/ebean/plugin/ExpressionPath.java
+++ b/ebean-api/src/main/java/io/ebean/plugin/ExpressionPath.java
@@ -37,7 +37,15 @@ public interface ExpressionPath {
   /**
    * Return the default StringParser for the scalar property.
    */
-  StringParser getStringParser();
+  StringParser stringParser();
+
+  /**
+   * Deprecated migrate to stringParser().
+   */
+  @Deprecated
+  default StringParser getStringParser() {
+    return stringParser();
+  }
 
   /**
    * For DateTime capable scalar types convert the long systemTimeMillis into
@@ -54,7 +62,15 @@ public interface ExpressionPath {
   /**
    * Return the underlying JDBC type or 0 if this is not a scalar type.
    */
-  int getJdbcType();
+  int jdbcType();
+
+  /**
+   * Deprecated migrate to jdbcType().
+   */
+  @Deprecated
+  default int getJdbcType() {
+    return jdbcType();
+  }
 
   /**
    * Return true if this is an ManyToOne or OneToOne associated bean property.
@@ -67,20 +83,52 @@ public interface ExpressionPath {
    * Typically used to produce id = ? expression strings.
    * </p>
    */
-  String getAssocIdExpression(String propName, String bindOperator);
+  String assocIdExpression(String propName, String bindOperator);
+
+  /**
+   * Deprecated migrate to assocIdExpression().
+   */
+  @Deprecated
+  default String getAssocIdExpression(String propName, String bindOperator) {
+    return assocIdExpression(propName, bindOperator);
+  }
 
   /**
    * Return the Id values for the given bean value.
    */
-  Object[] getAssocIdValues(EntityBean bean);
+  Object[] assocIdValues(EntityBean bean);
+
+  /**
+   * Deprecated migrate to assocIdValues().
+   */
+  @Deprecated
+  default Object[] getAssocIdValues(EntityBean bean) {
+    return assocIdValues(bean);
+  }
 
   /**
    * Return the underlying bean property.
    */
-  Property getProperty();
+  Property property();
+
+  /**
+   * Deprecated migrate to property().
+   */
+  @Deprecated
+  default Property getProperty() {
+    return property();
+  }
 
   /**
    * The ElPrefix plus name.
    */
-  String getElName();
+  String elName();
+
+  /**
+   * Deprecated migrate to elName().
+   */
+  @Deprecated
+  default String getElName() {
+    return elName();
+  }
 }
diff --git a/ebean-api/src/main/java/io/ebean/plugin/Property.java b/ebean-api/src/main/java/io/ebean/plugin/Property.java
index 20d81d7e5..50a1ebc3d 100644
--- a/ebean-api/src/main/java/io/ebean/plugin/Property.java
+++ b/ebean-api/src/main/java/io/ebean/plugin/Property.java
@@ -11,18 +11,42 @@ public interface Property {
    * Return the name of the property.
    */
   @Nonnull
-  String getName();
+  String name();
+
+  /**
+   * Deprecated migrate to name().
+   */
+  @Deprecated
+  default String getName() {
+    return name();
+  }
 
   /**
    * Return the type of the property.
    */
   @Nonnull
-  Class<?> getPropertyType();
+  Class<?> type();
+
+  /**
+   * Deprecated migrate to type().
+   */
+  @Deprecated
+  default Class<?> getPropertyType() {
+    return type();
+  }
 
   /**
    * Return the value of the property on the given bean.
    */
-  Object getVal(Object bean);
+  Object value(Object bean);
+
+  /**
+   * Deprecated migrate to value().
+   */
+  @Deprecated
+  default Object getVal(Object bean) {
+    return value(bean);
+  }
 
   /**
    * Return true if this is a OneToMany or ManyToMany property.
diff --git a/ebean-api/src/main/java/io/ebean/plugin/SpiServer.java b/ebean-api/src/main/java/io/ebean/plugin/SpiServer.java
index 257829a5e..96bf6eed1 100644
--- a/ebean-api/src/main/java/io/ebean/plugin/SpiServer.java
+++ b/ebean-api/src/main/java/io/ebean/plugin/SpiServer.java
@@ -16,32 +16,80 @@ public interface SpiServer extends Database {
   /**
    * Return the DatabaseConfig.
    */
-  DatabaseConfig getServerConfig();
+  DatabaseConfig config();
+
+  /**
+   * Migrate to config().
+   */
+  @Deprecated
+  default DatabaseConfig getServerConfig() {
+    return config();
+  }
 
   /**
    * Return the DatabasePlatform for this database.
    */
-  DatabasePlatform getDatabasePlatform();
+  DatabasePlatform databasePlatform();
+
+  /**
+   * Migrate to config().
+   */
+  @Deprecated
+  default DatabasePlatform getDatabasePlatform() {
+    return databasePlatform();
+  }
 
   /**
    * Return all the bean types registered on this server instance.
    */
-  List<? extends BeanType<?>> getBeanTypes();
+  List<? extends BeanType<?>> beanTypes();
+
+  /**
+   * Migrate to beanTypes().
+   */
+  @Deprecated
+  default List<? extends BeanType<?>> getBeanTypes() {
+    return beanTypes();
+  }
 
   /**
    * Return the bean type for a given entity bean class.
    */
-  <T> BeanType<T> getBeanType(Class<T> beanClass);
+  <T> BeanType<T> beanType(Class<T> beanClass);
+
+  /**
+   * Migrate to beanType().
+   */
+  @Deprecated
+  default <T> BeanType<T> getBeanType(Class<T> beanClass) {
+    return beanType(beanClass);
+  }
 
   /**
    * Return the bean types mapped to the given base table.
    */
-  List<? extends BeanType<?>> getBeanTypes(String baseTableName);
+  List<? extends BeanType<?>> beanTypes(String baseTableName);
+
+  /**
+   * Migrate to beanTypes().
+   */
+  @Deprecated
+  default List<? extends BeanType<?>> getBeanTypes(String baseTableName) {
+    return beanTypes(baseTableName);
+  }
 
   /**
    * Return the bean type for a given doc store queueId.
    */
-  BeanType<?> getBeanTypeForQueueId(String queueId);
+  BeanType<?> beanTypeForQueueId(String queueId);
+
+  /**
+   * Migrate to beanTypes().
+   */
+  @Deprecated
+  default BeanType<?> getBeanTypeForQueueId(String queueId) {
+    return beanTypeForQueueId(queueId);
+  }
 
   /**
    * Return a BeanLoader.
diff --git a/ebean-api/src/test/java/io/ebean/config/dbplatform/DbDefaultValueTest.java b/ebean-api/src/test/java/io/ebean/config/dbplatform/DbDefaultValueTest.java
index 2c94e989a..54c003c9c 100644
--- a/ebean-api/src/test/java/io/ebean/config/dbplatform/DbDefaultValueTest.java
+++ b/ebean-api/src/test/java/io/ebean/config/dbplatform/DbDefaultValueTest.java
@@ -1,6 +1,6 @@
 package io.ebean.config.dbplatform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Types;
 import java.time.LocalDate;
diff --git a/ebean-autotune/pom.xml b/ebean-autotune/pom.xml
index c244053d2..c98444f78 100644
--- a/ebean-autotune/pom.xml
+++ b/ebean-autotune/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 <!--  <parent>-->
 <!--    <groupId>org.avaje</groupId>-->
@@ -14,7 +14,7 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-parent-12.8.0</tag>
+    <tag>ebean-parent-12.11.4</tag>
   </scm>
 
   <name>ebean autotune</name>
@@ -26,7 +26,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
 
@@ -46,9 +46,9 @@
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.composite</groupId>
+      <groupId>io.avaje</groupId>
       <artifactId>junit</artifactId>
-      <version>1.1</version>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
@@ -59,12 +59,12 @@
       <plugin>
         <groupId>io.repaint.maven</groupId>
         <artifactId>tiles-maven-plugin</artifactId>
-        <version>2.19</version>
+        <version>2.24</version>
         <extensions>true</extensions>
         <configuration>
           <tiles>
             <!-- other tiles ... -->
-            <tile>io.ebean.tile:enhancement:12.6.0</tile>
+            <tile>io.ebean.tile:enhancement:12.11.3</tile>
           </tiles>
         </configuration>
       </plugin>
diff --git a/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/DefaultAutoTuneService.java b/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/DefaultAutoTuneService.java
index be2033695..b8d302f23 100644
--- a/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/DefaultAutoTuneService.java
+++ b/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/DefaultAutoTuneService.java
@@ -59,7 +59,7 @@ public class DefaultAutoTuneService implements AutoTuneService {
     this.tuningFile = config.getQueryTuningFile();
     this.profilingFile = config.getProfilingFile();
     this.profilingUpdateFrequency = config.getProfilingUpdateFrequency();
-    this.serverName = server.getName();
+    this.serverName = server.name();
     this.profileManager = new ProfileManager(config, server);
     this.queryTuner = new BaseQueryTuner(config, server, profileManager);
     this.skipGarbageCollectionOnShutdown = config.isSkipGarbageCollectionOnShutdown();
@@ -77,7 +77,7 @@ public class DefaultAutoTuneService implements AutoTuneService {
       loadTuningFile();
       if (isRuntimeTuningUpdates()) {
         // periodically gather and update query tuning
-        server.getBackgroundExecutor().scheduleWithFixedDelay(new ProfilingUpdate(), profilingUpdateFrequency, profilingUpdateFrequency, TimeUnit.SECONDS);
+        server.backgroundExecutor().scheduleWithFixedDelay(new ProfilingUpdate(), profilingUpdateFrequency, profilingUpdateFrequency, TimeUnit.SECONDS);
       }
     }
   }
diff --git a/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/ProfileManager.java b/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/ProfileManager.java
index 170a3a406..019955114 100644
--- a/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/ProfileManager.java
+++ b/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/ProfileManager.java
@@ -111,7 +111,7 @@ public class ProfileManager implements ProfilingListener {
   public AutoTuneCollection profilingCollection(boolean reset) {
     AutoTuneCollection req = new AutoTuneCollection();
     for (ProfileOrigin origin : profileMap.values()) {
-      BeanDescriptor<?> desc = server.getBeanDescriptorById(origin.getOrigin().getBeanType());
+      BeanDescriptor<?> desc = server.descriptorById(origin.getOrigin().getBeanType());
       if (desc != null) {
         origin.profilingCollection(desc, req, reset);
       }
diff --git a/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/ProfileOriginNodeUsage.java b/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/ProfileOriginNodeUsage.java
index 3ba6afa20..1f2a655dc 100644
--- a/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/ProfileOriginNodeUsage.java
+++ b/ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/ProfileOriginNodeUsage.java
@@ -43,14 +43,14 @@ public class ProfileOriginNodeUsage {
     try {
       BeanDescriptor<?> desc = rootDesc;
       if (path != null) {
-        ElPropertyValue elGetValue = rootDesc.getElGetValue(path);
+        ElPropertyValue elGetValue = rootDesc.elGetValue(path);
         if (elGetValue == null) {
-          logger.warn("AutoTune: Can't find join for path[" + path + "] for " + rootDesc.getName());
+          logger.warn("AutoTune: Can't find join for path[" + path + "] for " + rootDesc.name());
           return;
         } else {
-          BeanProperty beanProperty = elGetValue.getBeanProperty();
+          BeanProperty beanProperty = elGetValue.beanProperty();
           if (beanProperty instanceof BeanPropertyAssoc<?>) {
-            desc = ((BeanPropertyAssoc<?>) beanProperty).getTargetDescriptor();
+            desc = ((BeanPropertyAssoc<?>) beanProperty).targetDescriptor();
           }
         }
       }
@@ -61,7 +61,7 @@ public class ProfileOriginNodeUsage {
       for (String propName : aggregateUsed) {
         BeanProperty beanProp = desc.findPropertyFromPath(propName);
         if (beanProp == null) {
-          logger.warn("AutoTune: Can't find property[" + propName + "] for " + desc.getName());
+          logger.warn("AutoTune: Can't find property[" + propName + "] for " + desc.name());
 
         } else {
           if (beanProp.isId()) {
@@ -76,24 +76,24 @@ public class ProfileOriginNodeUsage {
               // (which is the default for Lob's so typical).
             } else {
               addedToPath = true;
-              pathProps.addToPath(path, beanProp.getName());
+              pathProps.addToPath(path, beanProp.name());
             }
           }
         }
       }
 
       if ((modified || addVersionProperty) && desc != null) {
-        BeanProperty versionProp = desc.getVersionProperty();
+        BeanProperty versionProp = desc.versionProperty();
         if (versionProp != null) {
           addedToPath = true;
-          pathProps.addToPath(path, versionProp.getName());
+          pathProps.addToPath(path, versionProp.name());
         }
       }
 
       if (toOneIdProperty != null && !addedToPath) {
         // add ToOne property to parent path
-        ElPropertyValue assocOne = rootDesc.getElGetValue(path);
-        pathProps.addToPath(SplitName.parent(path), assocOne.getName());
+        ElPropertyValue assocOne = rootDesc.elGetValue(path);
+        pathProps.addToPath(SplitName.parent(path), assocOne.name());
       }
     } finally {
       lock.unlock();
diff --git a/ebean-autotune/src/test/java/io/ebeaninternal/server/autotune/service/AutoTuneXmlReaderTest.java b/ebean-autotune/src/test/java/io/ebeaninternal/server/autotune/service/AutoTuneXmlReaderTest.java
index 845e68624..d67f2ec64 100644
--- a/ebean-autotune/src/test/java/io/ebeaninternal/server/autotune/service/AutoTuneXmlReaderTest.java
+++ b/ebean-autotune/src/test/java/io/ebeaninternal/server/autotune/service/AutoTuneXmlReaderTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.autotune.service;
 
 import io.ebeaninternal.server.autotune.model.Autotune;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.File;
 import java.io.InputStream;
diff --git a/ebean-autotune/src/test/java/io/ebeaninternal/server/autotune/service/ProfileOriginTest.java b/ebean-autotune/src/test/java/io/ebeaninternal/server/autotune/service/ProfileOriginTest.java
index b1f982024..9f981a404 100644
--- a/ebean-autotune/src/test/java/io/ebeaninternal/server/autotune/service/ProfileOriginTest.java
+++ b/ebean-autotune/src/test/java/io/ebeaninternal/server/autotune/service/ProfileOriginTest.java
@@ -5,7 +5,7 @@ import io.ebean.bean.ObjectGraphNode;
 import io.ebean.bean.ObjectGraphOrigin;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.querydefn.OrmQueryDetail;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.autofetch.BaseTestCase;
 import org.tests.model.basic.Order;
 
diff --git a/ebean-autotune/src/test/java/org/tests/autofetch/BaseTestCase.java b/ebean-autotune/src/test/java/org/tests/autofetch/BaseTestCase.java
index e59dbbb4b..102affc90 100644
--- a/ebean-autotune/src/test/java/org/tests/autofetch/BaseTestCase.java
+++ b/ebean-autotune/src/test/java/org/tests/autofetch/BaseTestCase.java
@@ -11,6 +11,6 @@ public class BaseTestCase {
   }
 
   protected <T> BeanDescriptor<T> getBeanDescriptor(Class<T> cls) {
-    return spiEbeanServer().getBeanDescriptor(cls);
+    return spiEbeanServer().descriptor(cls);
   }
 }
diff --git a/ebean-bom/pom.xml b/ebean-bom/pom.xml
index 6468059fe..a21697986 100644
--- a/ebean-bom/pom.xml
+++ b/ebean-bom/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <name>ebean bom</name>
@@ -71,88 +71,88 @@
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-api</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-core</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-core-type</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-ddl-generator</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-externalmapping-api</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-externalmapping-xml</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-autotune</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-querybean</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>querybean-generator</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
         <scope>provided</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>kotlin-querybean-generator</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
         <scope>provided</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-test</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
         <scope>test</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-postgis</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-redis</artifactId>
-        <version>12.11.2-SNAPSHOT</version>
+        <version>12.11.5-SNAPSHOT</version>
       </dependency>
 
     </dependencies>
diff --git a/ebean-core-type/pom.xml b/ebean-core-type/pom.xml
index 10c45ea74..512ed0b45 100644
--- a/ebean-core-type/pom.xml
+++ b/ebean-core-type/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <artifactId>ebean-core-type</artifactId>
@@ -16,7 +16,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-api</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
     </dependency>
 
     <dependency>
diff --git a/ebean-core/pom.xml b/ebean-core/pom.xml
index 66eb107fb..b4ae7fb11 100644
--- a/ebean-core/pom.xml
+++ b/ebean-core/pom.xml
@@ -3,7 +3,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <artifactId>ebean-core</artifactId>
@@ -15,35 +15,21 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-parent-12.8.0</tag>
+    <tag>ebean-parent-12.11.4</tag>
   </scm>
 
-  <profiles>
-    <profile>
-      <id>db2</id>
-      <dependencies>
-        <!-- https://mvnrepository.com/artifact/com.ibm.db2/jcc -->
-        <dependency>
-          <groupId>com.ibm.db2</groupId>
-          <artifactId>jcc</artifactId>
-          <version>11.5.5.0</version>
-          <scope>test</scope>
-        </dependency>
-      </dependencies>
-    </profile>
-  </profiles>
   <dependencies>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-ddl-runner</artifactId>
-      <version>1.0</version>
+      <version>1.1</version>
     </dependency>
 
     <dependency>
       <groupId>io.avaje</groupId>
       <artifactId>classpath-scanner</artifactId>
-      <version>6.0</version>
+      <version>6.1</version>
     </dependency>
 
     <dependency>
@@ -52,45 +38,22 @@
       <version>1.1</version>
     </dependency>
 
-    <!-- keep testing in core using ebean-ddl-generator & ebean-migration -->
-    <dependency>
-      <groupId>io.ebean</groupId>
-      <artifactId>ebean-migration</artifactId>
-      <version>12.4.0</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>io.ebean</groupId>
-      <artifactId>ebean-ddl-generator</artifactId>
-      <version>12.11.0</version>
-      <scope>test</scope>
-    </dependency>
-
-    <!-- test scope for supporting ebean-ddl-generator -->
-    <dependency>
-      <groupId>org.glassfish.jaxb</groupId>
-      <artifactId>jaxb-runtime</artifactId>
-      <version>2.3.2</version>
-      <scope>test</scope>
-    </dependency>
-
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-api</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core-type</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-externalmapping-api</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
     </dependency>
 
     <dependency>
@@ -105,8 +68,8 @@
     -->
     <dependency>
       <groupId>io.avaje</groupId>
-      <artifactId>avaje-jsr305</artifactId>
-      <version>1.0</version>
+      <artifactId>avaje-jsr305-x</artifactId>
+      <version>1.1</version>
       <scope>provided</scope>
     </dependency>
 
@@ -121,8 +84,8 @@
 
     <dependency>
       <groupId>javax.transaction</groupId>
-      <artifactId>jta</artifactId>
-      <version>1.1</version>
+      <artifactId>javax.transaction-api</artifactId>
+      <version>1.3</version>
       <optional>true</optional>
     </dependency>
 
@@ -130,7 +93,7 @@
     <dependency>
       <groupId>javax.validation</groupId>
       <artifactId>validation-api</artifactId>
-      <version>1.1.0.Final</version>
+      <version>2.0.1.Final</version>
       <optional>true</optional>
     </dependency>
     <dependency>
@@ -147,12 +110,12 @@
       <optional>true</optional>
     </dependency>
 
-    <dependency>
-      <groupId>javax.annotation</groupId>
-      <artifactId>javax.annotation-api</artifactId>
-      <version>1.3.2</version>
-      <optional>true</optional>
-    </dependency>
+<!--    <dependency>-->
+<!--      <groupId>javax.annotation</groupId>-->
+<!--      <artifactId>javax.annotation-api</artifactId>-->
+<!--      <version>1.3.2</version>-->
+<!--      <optional>true</optional>-->
+<!--    </dependency>-->
 
     <!-- Jackson core used internally by Ebean -->
     <dependency>
@@ -186,107 +149,15 @@
       <scope>test</scope>
     </dependency>
 
-    <dependency>
-      <groupId>com.nuodb.jdbc</groupId>
-      <artifactId>nuodb-jdbc</artifactId>
-      <version>20.2.0</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>com.oracle.ojdbc</groupId>
-      <artifactId>ojdbc10</artifactId>
-      <version>19.3.0.0</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>io.ebean</groupId>
-      <artifactId>ebean-test-docker</artifactId>
-      <version>4.1</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>ch.qos.logback</groupId>
-      <artifactId>logback-classic</artifactId>
-      <version>1.2.3</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.xerial</groupId>
-      <artifactId>sqlite-jdbc</artifactId>
-      <version>3.15.1</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.hsqldb</groupId>
-      <artifactId>hsqldb</artifactId>
-      <version>2.3.4</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>com.microsoft.sqlserver</groupId>
-      <artifactId>mssql-jdbc</artifactId>
-      <version>7.2.2.jre8</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>mysql</groupId>
-      <artifactId>mysql-connector-java</artifactId>
-      <version>8.0.17</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.mariadb.jdbc</groupId>
-      <artifactId>mariadb-java-client</artifactId>
-      <version>2.6.0</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>com.sap.cloud.db.jdbc</groupId>
-      <artifactId>ngdbc</artifactId>
-      <version>2.3.48</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.mockito</groupId>
-      <artifactId>mockito-core</artifactId>
-      <version>3.0.0</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.avaje.composite</groupId>
-      <artifactId>junit</artifactId>
-      <version>1.1</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>commons-io</groupId>
-      <artifactId>commons-io</artifactId>
-      <version>2.7</version>
-      <scope>test</scope>
-    </dependency>
-
     <dependency>
       <groupId>io.avaje</groupId>
-      <artifactId>mod-uuid</artifactId>
-      <version>1.1</version>
+      <artifactId>junit</artifactId>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
   </dependencies>
 
-
   <build>
     <plugins>
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanBuffer.java b/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanBuffer.java
index 346da41fd..3b999bc3c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanBuffer.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanBuffer.java
@@ -11,15 +11,15 @@ import java.util.List;
  */
 public interface LoadBeanBuffer {
 
-  int getBatchSize();
+  int batchSize();
 
-  List<EntityBeanIntercept> getBatch();
+  List<EntityBeanIntercept> batch();
 
-  BeanDescriptor<?> getBeanDescriptor();
+  BeanDescriptor<?> descriptor();
 
-  PersistenceContext getPersistenceContext();
+  PersistenceContext persistenceContext();
 
-  String getFullPath();
+  String fullPath();
 
   void configureQuery(SpiQuery<?> query, String lazyLoadProperty);
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanRequest.java b/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanRequest.java
index a763182b2..ffe28462c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanRequest.java
@@ -1,7 +1,8 @@
 package io.ebeaninternal.api;
 
-import io.ebean.bean.EntityBean;
+import io.ebean.CacheMode;
 import io.ebean.bean.EntityBeanIntercept;
+import io.ebeaninternal.api.SpiQuery.Mode;
 import io.ebeaninternal.server.core.OrmQueryRequest;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 
@@ -19,77 +20,54 @@ public final class LoadBeanRequest extends LoadRequest {
   private final LoadBeanBuffer loadBuffer;
   private final String lazyLoadProperty;
   private final boolean loadCache;
-  private boolean loadedFromCache;
+  private final boolean alreadyLoaded;
 
   /**
    * Construct for lazy load request.
    */
-  public LoadBeanRequest(LoadBeanBuffer LoadBuffer, EntityBeanIntercept ebi, boolean loadCache) {
-    this(LoadBuffer, null, true, ebi.getLazyLoadProperty(), loadCache);
-    this.loadedFromCache = ebi.isLoadedFromCache();
+  public LoadBeanRequest(LoadBeanBuffer loadBuffer, EntityBeanIntercept ebi, boolean loadCache) {
+    this(loadBuffer, null, true, ebi.getLazyLoadProperty(), ebi.isLoaded(), loadCache || ebi.isLoadedFromCache());
   }
 
   /**
    * Construct for secondary query.
    */
-  public LoadBeanRequest(LoadBeanBuffer LoadBuffer, OrmQueryRequest<?> parentRequest) {
-    this(LoadBuffer, parentRequest, false, null, false);
+  public LoadBeanRequest(LoadBeanBuffer loadBuffer, OrmQueryRequest<?> parentRequest) {
+    this(loadBuffer, parentRequest, false, null, false, false);
   }
 
   private LoadBeanRequest(LoadBeanBuffer loadBuffer, OrmQueryRequest<?> parentRequest, boolean lazy,
-                          String lazyLoadProperty, boolean loadCache) {
-
+                          String lazyLoadProperty, boolean alreadyLoaded, boolean loadCache) {
     super(parentRequest, lazy);
     this.loadBuffer = loadBuffer;
-    this.batch = loadBuffer.getBatch();
+    this.batch = loadBuffer.batch();
     this.lazyLoadProperty = lazyLoadProperty;
+    this.alreadyLoaded = alreadyLoaded;
     this.loadCache = loadCache;
   }
 
   @Override
-  public Class<?> getBeanType() {
-    return loadBuffer.getBeanDescriptor().getBeanType();
+  public Class<?> beanType() {
+    return loadBuffer.descriptor().type();
   }
 
-  /**
-   * Return true if the beans invoking lazy loading were previously loaded from cache.
-   */
-  public boolean isLoadedFromCache() {
-    return loadedFromCache;
-  }
-
-  private boolean isLoadCache() {
-    return loadCache;
-  }
-
-  public String getDescription() {
-    return "path:" + loadBuffer.getFullPath() + " batch:" + batch.size();
+  public String description() {
+    return loadBuffer.fullPath();
   }
 
   /**
    * Return the batch of beans to actually load.
    */
-  public List<EntityBeanIntercept> getBatch() {
+  public List<EntityBeanIntercept> batch() {
     return batch;
   }
 
-  /**
-   * Return the load context.
-   */
-  private LoadBeanBuffer getLoadContext() {
-    return loadBuffer;
-  }
-
-  public int getBatchSize() {
-    return getLoadContext().getBatchSize();
-  }
-
   /**
    * Return the list of Id values for the beans in the lazy load buffer.
    */
   public List<Object> getIdList() {
     List<Object> idList = new ArrayList<>();
-    BeanDescriptor<?> desc = loadBuffer.getBeanDescriptor();
+    BeanDescriptor<?> desc = loadBuffer.descriptor();
     for (EntityBeanIntercept ebi : batch) {
       idList.add(desc.getId(ebi.getOwner()));
     }
@@ -100,16 +78,21 @@ public final class LoadBeanRequest extends LoadRequest {
    * Configure the query for lazy loading execution.
    */
   public void configureQuery(SpiQuery<?> query, List<Object> idList) {
-    query.setMode(SpiQuery.Mode.LAZYLOAD_BEAN);
-    query.setPersistenceContext(loadBuffer.getPersistenceContext());
-    String mode = isLazy() ? "+lazy" : "+query";
-    query.setLoadDescription(mode, getDescription());
-
-    if (isLazy()) {
-      // cascade the batch size (if set) for further lazy loading
-      query.setLazyLoadBatchSize(getBatchSize());
+    query.setMode(Mode.LAZYLOAD_BEAN);
+    query.setPersistenceContext(loadBuffer.persistenceContext());
+    query.setLoadDescription(lazy ? "+lazy" : "+query", description());
+    if (lazy) {
+      query.setLazyLoadBatchSize(loadBuffer.batchSize());
+      if (alreadyLoaded) {
+        query.setBeanCacheMode(CacheMode.OFF);
+      }
+    } else {
+      query.setBeanCacheMode(CacheMode.OFF);
     }
     loadBuffer.configureQuery(query, lazyLoadProperty);
+    if (loadCache) {
+      query.setBeanCacheMode(CacheMode.PUT);
+    }
     if (idList.size() == 1) {
       query.where().idEq(idList.get(0));
     } else {
@@ -122,13 +105,12 @@ public final class LoadBeanRequest extends LoadRequest {
    */
   public void postLoad(List<?> list) {
     Set<Object> loadedIds = new HashSet<>();
-    BeanDescriptor<?> desc = loadBuffer.getBeanDescriptor();
+    BeanDescriptor<?> desc = loadBuffer.descriptor();
     // collect Ids and maybe load bean cache
     for (Object bean : list) {
-      EntityBean loadedBean = (EntityBean) bean;
-      loadedIds.add(desc.getId(loadedBean));
+      loadedIds.add(desc.id(bean));
     }
-    if (isLoadCache()) {
+    if (loadCache) {
       desc.cacheBeanPutAll(list);
     }
     if (lazyLoadProperty != null) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/LoadManyRequest.java b/ebean-core/src/main/java/io/ebeaninternal/api/LoadManyRequest.java
index cd49558d6..a304be78d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/LoadManyRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/LoadManyRequest.java
@@ -1,5 +1,6 @@
 package io.ebeaninternal.api;
 
+import io.ebean.CacheMode;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebeaninternal.server.core.BindPadding;
@@ -47,96 +48,58 @@ public final class LoadManyRequest extends LoadRequest {
   }
 
   @Override
-  public Class<?> getBeanType() {
-    return loadContext.getBeanDescriptor().getBeanType();
+  public Class<?> beanType() {
+    return loadContext.getBeanDescriptor().type();
   }
 
-  public String getDescription() {
-    return "path:" + loadContext.getFullPath() + " size:" + batch.size();
-  }
-
-  /**
-   * Return the batch of collections to actually load.
-   */
-  public List<BeanCollection<?>> getBatch() {
-    return batch;
-  }
-
-  /**
-   * Return true if lazy loading should only load the id values.
-   * <p>
-   * This for use when lazy loading is invoked on methods such as clear() and removeAll() where it
-   * generally makes sense to only fetch the Id values as the other property information is not
-   * used.
-   */
-  private boolean isOnlyIds() {
-    return onlyIds;
-  }
-
-  /**
-   * Return true if we should load the Collection ids into the cache.
-   */
-  private boolean isLoadCache() {
-    return loadCache;
-  }
-
-  /**
-   * Return the batch size used for this load context.
-   */
-  public int getBatchSize() {
-    return loadContext.getBatchSize();
+  public String description() {
+    return loadContext.getFullPath();
   }
 
   private List<Object> parentIdList(SpiEbeanServer server) {
     List<Object> idList = new ArrayList<>();
-    BeanPropertyAssocMany<?> many = getMany();
+    BeanPropertyAssocMany<?> many = many();
     for (BeanCollection<?> bc : batch) {
-      idList.add(many.getParentId(bc.getOwnerBean()));
+      idList.add(many.parentId(bc.getOwnerBean()));
       bc.setLoader(server); // don't use the load buffer again
     }
-    if (many.getTargetDescriptor().isPadInExpression()) {
+    if (many.targetDescriptor().isPadInExpression()) {
       BindPadding.padIds(idList);
     }
     return idList;
   }
 
-  private BeanPropertyAssocMany<?> getMany() {
+  private BeanPropertyAssocMany<?> many() {
     return loadContext.getBeanProperty();
   }
 
   public SpiQuery<?> createQuery(SpiEbeanServer server) {
-    BeanPropertyAssocMany<?> many = getMany();
+    BeanPropertyAssocMany<?> many = many();
     SpiQuery<?> query = many.newQuery(server);
-    String orderBy = many.getLazyFetchOrderBy();
+    String orderBy = many.lazyFetchOrderBy();
     if (orderBy != null) {
       query.order(orderBy);
     }
-
-    String extraWhere = many.getExtraWhere();
+    String extraWhere = many.extraWhere();
     if (extraWhere != null) {
       // replace special ${ta} placeholder with the base table alias
       // which is always t0 and add the extra where clause
       query.where().raw(extraWhere.replace("${ta}", "t0").replace("${mta}", "int_"));
     }
-
     query.setLazyLoadForParents(many);
     many.addWhereParentIdIn(query, parentIdList(server), loadContext.isUseDocStore());
     query.setPersistenceContext(loadContext.getPersistenceContext());
-
-    String mode = isLazy() ? "+lazy" : "+query";
-    query.setLoadDescription(mode, getDescription());
-
-    if (isLazy()) {
-      // cascade the batch size (if set) for further lazy loading
-      query.setLazyLoadBatchSize(getBatchSize());
+    query.setLoadDescription(lazy ? "+lazy" : "+query", description());
+    if (lazy) {
+      query.setLazyLoadBatchSize(loadContext.getBatchSize());
+    } else {
+      query.setBeanCacheMode(CacheMode.OFF);
     }
-
-    // potentially changes the joins and selected properties
+    // potentially changes the joins, selected properties, cache mode
     loadContext.configureQuery(query);
-
-    if (isOnlyIds()) {
-      // override to just select the Id values
-      query.select(many.getTargetIdProperty());
+    if (onlyIds) {
+      // lazy loading invoked via clear() and removeAll()
+      query.select(many.targetIdProperty());
     }
     return query;
   }
@@ -146,7 +109,7 @@ public final class LoadManyRequest extends LoadRequest {
    */
   public void postLoad() {
     BeanDescriptor<?> desc = loadContext.getBeanDescriptor();
-    BeanPropertyAssocMany<?> many = getMany();
+    BeanPropertyAssocMany<?> many = many();
     // check for BeanCollection's that where never processed
     // in the +query or +lazy load due to no rows (predicates)
     for (BeanCollection<?> bc : batch) {
@@ -156,9 +119,8 @@ public final class LoadManyRequest extends LoadRequest {
           Object parentId = desc.getId(ownerBean);
           logger.debug("BeanCollection after lazy load was empty. type:" + ownerBean.getClass().getName() + " id:" + parentId + " owner:" + ownerBean);
         }
-      } else if (isLoadCache() && many.isUseCache()) {
-        Object parentId = desc.getId(bc.getOwnerBean());
-        desc.cacheManyPropPut(many, bc, parentId);
+      } else if (loadCache && many.isUseCache()) {
+        desc.cacheManyPropPut(many, bc, desc.getId(bc.getOwnerBean()));
       }
     }
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/LoadRequest.java b/ebean-core/src/main/java/io/ebeaninternal/api/LoadRequest.java
index 516bcddb2..b8259d5b1 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/LoadRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/LoadRequest.java
@@ -9,22 +9,19 @@ import io.ebeaninternal.server.core.OrmQueryRequest;
 public abstract class LoadRequest {
 
   protected final OrmQueryRequest<?> parentRequest;
-
   protected final Transaction transaction;
-
   protected final boolean lazy;
 
-  public LoadRequest(OrmQueryRequest<?> parentRequest, boolean lazy) {
-
+  LoadRequest(OrmQueryRequest<?> parentRequest, boolean lazy) {
     this.parentRequest = parentRequest;
-    this.transaction = parentRequest == null ? null : parentRequest.getTransaction();
+    this.transaction = parentRequest == null ? null : parentRequest.transaction();
     this.lazy = lazy;
   }
 
   /**
    * Return the associated bean type for this load request.
    */
-  public abstract Class<?> getBeanType();
+  public abstract Class<?> beanType();
 
   /**
    * Return true if this is a lazy load and false if it is a secondary query.
@@ -39,7 +36,7 @@ public abstract class LoadRequest {
    * Lazy loading queries run in their own transaction.
    * </p>
    */
-  public Transaction getTransaction() {
+  public Transaction transaction() {
     return transaction;
   }
 
@@ -48,6 +45,6 @@ public abstract class LoadRequest {
    * So one of - findIterate(), findEach(), findEachWhile() or findVisit().
    */
   public boolean isParentFindIterate() {
-    return parentRequest != null && parentRequest.getQuery().getType() == SpiQuery.Type.ITERATE;
+    return parentRequest != null && parentRequest.query().getType() == SpiQuery.Type.ITERATE;
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/ManyWhereJoins.java b/ebean-core/src/main/java/io/ebeaninternal/api/ManyWhereJoins.java
index 91fc49d21..93e4111ef 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/ManyWhereJoins.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/ManyWhereJoins.java
@@ -49,15 +49,15 @@ public final class ManyWhereJoins implements Serializable {
    */
   public void add(ElPropertyDeploy elProp) {
 
-    String join = elProp.getElPrefix();
-    BeanProperty p = elProp.getBeanProperty();
+    String join = elProp.elPrefix();
+    BeanProperty p = elProp.beanProperty();
     if (p instanceof BeanPropertyAssocMany<?>) {
-      join = addManyToJoin(join, p.getName());
+      join = addManyToJoin(join, p.name());
     }
     if (join != null) {
       addJoin(join);
       if (p != null) {
-        String secondaryTableJoinPrefix = p.getSecondaryTableJoinPrefix();
+        String secondaryTableJoinPrefix = p.secondaryTableJoinPrefix();
         if (secondaryTableJoinPrefix != null) {
           addJoin(join + "." + secondaryTableJoinPrefix);
         }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/SpiBeanTypeManager.java b/ebean-core/src/main/java/io/ebeaninternal/api/SpiBeanTypeManager.java
index 0a6b79d78..57e19db81 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/SpiBeanTypeManager.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/SpiBeanTypeManager.java
@@ -8,6 +8,6 @@ public interface SpiBeanTypeManager {
   /**
    * Return the bean type for the given entity class.
    */
-  SpiBeanType getBeanType(Class<?> entityType);
+  SpiBeanType beanType(Class<?> entityType);
 
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/SpiDtoQuery.java b/ebean-core/src/main/java/io/ebeaninternal/api/SpiDtoQuery.java
index 16cee411c..cc64fb097 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/SpiDtoQuery.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/SpiDtoQuery.java
@@ -36,11 +36,6 @@ public interface SpiDtoQuery<T> extends DtoQuery<T>, SpiSqlBinding {
    */
   boolean isRelaxedMode();
 
-  /**
-   * Return the label for the query.
-   */
-  String getLabel();
-
   /**
    * Return the label with fallback to profile location label.
    */
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/SpiEbeanServer.java b/ebean-core/src/main/java/io/ebeaninternal/api/SpiEbeanServer.java
index fae60f49d..449a528f4 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/SpiEbeanServer.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/SpiEbeanServer.java
@@ -8,6 +8,7 @@ import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.event.readaudit.ReadAuditLogger;
 import io.ebean.event.readaudit.ReadAuditPrepare;
 import io.ebean.meta.MetricVisitor;
+import io.ebean.plugin.SpiServer;
 import io.ebeaninternal.api.SpiQuery.Type;
 import io.ebeaninternal.server.core.SpiResultSet;
 import io.ebeaninternal.server.core.timezone.DataTimeZone;
@@ -23,7 +24,7 @@ import java.util.stream.Stream;
 /**
  * Service Provider extension to EbeanServer.
  */
-public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollectionLoader {
+public interface SpiEbeanServer extends SpiServer, ExtendedServer, EbeanServer, BeanCollectionLoader {
 
   /**
    * Return true if the L2 cache has been disabled.
@@ -50,16 +51,6 @@ public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollect
    */
   Object currentTenantId();
 
-  /**
-   * Return the server configuration.
-   */
-  DatabaseConfig getServerConfig();
-
-  /**
-   * Return the DatabasePlatform for this server.
-   */
-  DatabasePlatform getDatabasePlatform();
-
   /**
    * Create an object to represent the current CallStack.
    * <p>
@@ -72,7 +63,7 @@ public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollect
   /**
    * Return the PersistenceContextScope to use defined at query or server level.
    */
-  PersistenceContextScope getPersistenceContextScope(SpiQuery<?> query);
+  PersistenceContextScope persistenceContextScope(SpiQuery<?> query);
 
   /**
    * Clear the query execution statistics.
@@ -82,32 +73,32 @@ public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollect
   /**
    * Return the transaction manager.
    */
-  SpiTransactionManager getTransactionManager();
+  SpiTransactionManager transactionManager();
 
   /**
    * Return all the descriptors.
    */
-  List<BeanDescriptor<?>> getBeanDescriptors();
+  List<BeanDescriptor<?>> descriptors();
 
   /**
    * Return the BeanDescriptor for a given type of bean.
    */
-  <T> BeanDescriptor<T> getBeanDescriptor(Class<T> type);
+  <T> BeanDescriptor<T> descriptor(Class<T> type);
 
   /**
    * Return BeanDescriptor using it's unique id.
    */
-  BeanDescriptor<?> getBeanDescriptorById(String className);
+  BeanDescriptor<?> descriptorById(String className);
 
   /**
    * Return BeanDescriptor using it's unique doc store queueId.
    */
-  BeanDescriptor<?> getBeanDescriptorByQueueId(String queueId);
+  BeanDescriptor<?> descriptorByQueueId(String queueId);
 
   /**
    * Return BeanDescriptors mapped to this table.
    */
-  List<BeanDescriptor<?>> getBeanDescriptors(String tableName);
+  List<BeanDescriptor<?>> descriptors(String tableName);
 
   /**
    * Process committed changes from another framework.
@@ -179,7 +170,7 @@ public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollect
   /**
    * Return the default batch size for lazy loading.
    */
-  int getLazyLoadBatchSize();
+  int lazyLoadBatchSize();
 
   /**
    * Return true if the type is known as an Entity or Xml type or a List Set or
@@ -190,18 +181,18 @@ public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollect
   /**
    * Return the ReadAuditLogger to use for logging all read audit events.
    */
-  ReadAuditLogger getReadAuditLogger();
+  ReadAuditLogger readAuditLogger();
 
   /**
    * Return the ReadAuditPrepare used to populate the read audit events with
    * user context information (user id, user ip address etc).
    */
-  ReadAuditPrepare getReadAuditPrepare();
+  ReadAuditPrepare readAuditPrepare();
 
   /**
    * Return the DataTimeZone to use when reading/writing timestamps via JDBC.
    */
-  DataTimeZone getDataTimeZone();
+  DataTimeZone dataTimeZone();
 
   /**
    * Check for slow query event.
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/SpiExpressionList.java b/ebean-core/src/main/java/io/ebeaninternal/api/SpiExpressionList.java
index c4764b30f..5c4ce37ed 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/SpiExpressionList.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/SpiExpressionList.java
@@ -44,8 +44,4 @@ public interface SpiExpressionList<T> extends ExpressionList<T>, SpiExpression {
     // do nothing by default
   }
 
-  /**
-   * Apply property prefix when filterMany expressions included in main query.
-   */
-  void prefixProperty(String path);
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/SpiTransactionProxy.java b/ebean-core/src/main/java/io/ebeaninternal/api/SpiTransactionProxy.java
index a63c04cc6..03824903b 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/SpiTransactionProxy.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/SpiTransactionProxy.java
@@ -318,8 +318,8 @@ public abstract class SpiTransactionProxy implements SpiTransaction {
   }
 
   @Override
-  public Connection getConnection() {
-    return transaction.getConnection();
+  public Connection connection() {
+    return transaction.connection();
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/TransactionEventTable.java b/ebean-core/src/main/java/io/ebeaninternal/api/TransactionEventTable.java
index de55cd163..d9bf0f3a3 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/TransactionEventTable.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/TransactionEventTable.java
@@ -39,7 +39,7 @@ public final class TransactionEventTable implements Serializable, BinaryWritable
   }
 
   public void add(TableIUD newTableIUD) {
-    TableIUD existingTableIUD = map.put(newTableIUD.getTableName(), newTableIUD);
+    TableIUD existingTableIUD = map.put(newTableIUD.tableName(), newTableIUD);
     if (existingTableIUD != null) {
       newTableIUD.add(existingTableIUD);
     }
@@ -104,7 +104,7 @@ public final class TransactionEventTable implements Serializable, BinaryWritable
     }
 
     @Override
-    public String getTableName() {
+    public String tableName() {
       return table;
     }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/cache/CacheChangeSet.java b/ebean-core/src/main/java/io/ebeaninternal/server/cache/CacheChangeSet.java
index a1393db06..298b856df 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/cache/CacheChangeSet.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/cache/CacheChangeSet.java
@@ -63,7 +63,7 @@ public final class CacheChangeSet {
    * Add an entry to clear a query cache.
    */
   public void addInvalidate(BeanDescriptor<?> descriptor) {
-    touchedTables.add(descriptor.getBaseTable());
+    touchedTables.add(descriptor.baseTable());
   }
 
   /**
@@ -78,7 +78,7 @@ public final class CacheChangeSet {
    */
   public void addClearQuery(BeanDescriptor<?> descriptor) {
     queryCaches.add(descriptor);
-    touchedTables.add(descriptor.getBaseTable());
+    touchedTables.add(descriptor.baseTable());
   }
 
   /**
@@ -125,7 +125,7 @@ public final class CacheChangeSet {
       entry.addId(id);
     } else {
       beanRemoveMap.put(desc, new CacheChangeBeanRemove(id, desc));
-      touchedTables.add(desc.getBaseTable());
+      touchedTables.add(desc.baseTable());
     }
   }
 
@@ -138,7 +138,7 @@ public final class CacheChangeSet {
       entry.addIds(ids);
     } else {
       beanRemoveMap.put(desc, new CacheChangeBeanRemove(desc, ids));
-      touchedTables.add(desc.getBaseTable());
+      touchedTables.add(desc.baseTable());
     }
   }
 
@@ -146,7 +146,7 @@ public final class CacheChangeSet {
    * Update a bean entry.
    */
   public <T> void addBeanUpdate(BeanDescriptor<T> desc, String key, Map<String, Object> changes, boolean updateNaturalKey, long version) {
-    touchedTables.add(desc.getBaseTable());
+    touchedTables.add(desc.baseTable());
     entries.add(new CacheChangeBeanUpdate(desc, key, changes, updateNaturalKey, version));
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanDataFromBean.java b/ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanDataFromBean.java
index 2fd3fd46b..2405e03bc 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanDataFromBean.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanDataFromBean.java
@@ -15,33 +15,33 @@ public final class CachedBeanDataFromBean {
     EntityBeanIntercept ebi = bean._ebean_getIntercept();
     Map<String, Object> data = new LinkedHashMap<>();
 
-    BeanProperty idProperty = desc.getIdProperty();
+    BeanProperty idProperty = desc.idProperty();
     if (idProperty != null) {
-      int propertyIndex = idProperty.getPropertyIndex();
+      int propertyIndex = idProperty.propertyIndex();
       if (ebi.isLoadedProperty(propertyIndex)) {
-        data.put(idProperty.getName(), idProperty.getCacheDataValue(bean));
+        data.put(idProperty.name(), idProperty.getCacheDataValue(bean));
       }
     }
 
     // extract all the non-many properties
     final boolean dirty = ebi.isDirty();
     for (BeanProperty prop : desc.propertiesNonMany()) {
-      if (dirty && ebi.isDirtyProperty(prop.getPropertyIndex())) {
-        data.put(prop.getName(), prop.getCacheDataValueOrig(ebi));
-      } else if (ebi.isLoadedProperty(prop.getPropertyIndex())) {
-        data.put(prop.getName(), prop.getCacheDataValue(bean));
+      if (dirty && ebi.isDirtyProperty(prop.propertyIndex())) {
+        data.put(prop.name(), prop.getCacheDataValueOrig(ebi));
+      } else if (ebi.isLoadedProperty(prop.propertyIndex())) {
+        data.put(prop.name(), prop.getCacheDataValue(bean));
       }
     }
 
     for (BeanPropertyAssocMany<?> prop : desc.propertiesMany()) {
       if (prop.isElementCollection()) {
-        data.put(prop.getName(), prop.getCacheDataValue(bean));
+        data.put(prop.name(), prop.getCacheDataValue(bean));
       }
     }
 
     long version = desc.getVersion(bean);
     EntityBean sharableBean = createSharableBean(desc, bean, ebi);
-    return new CachedBeanData(sharableBean, desc.getDiscValue(), data, version);
+    return new CachedBeanData(sharableBean, desc.discValue(), data, version);
   }
 
   private static EntityBean createSharableBean(BeanDescriptor<?> desc, EntityBean bean, EntityBeanIntercept beanEbi) {
@@ -54,7 +54,7 @@ public final class CachedBeanDataFromBean {
 
     // create a readOnly sharable instance by copying the data
     EntityBean sharableBean = desc.createEntityBean();
-    BeanProperty idProp = desc.getIdProperty();
+    BeanProperty idProp = desc.idProperty();
     if (idProp != null) {
       Object v = idProp.getValue(bean);
       idProp.setValue(sharableBean, v);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanDataToBean.java b/ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanDataToBean.java
index 08f3a80fd..ae5b922a9 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanDataToBean.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanDataToBean.java
@@ -13,9 +13,9 @@ public final class CachedBeanDataToBean {
     EntityBeanIntercept ebi = bean._ebean_getIntercept();
     // any future lazy loading skips L2 bean cache
     ebi.setLoadedFromCache(true);
-    BeanProperty idProperty = desc.getIdProperty();
-    if (desc.getInheritInfo() != null) {
-        desc = desc.getInheritInfo().readType(bean.getClass()).desc();
+    BeanProperty idProperty = desc.idProperty();
+    if (desc.inheritInfo() != null) {
+        desc = desc.inheritInfo().readType(bean.getClass()).desc();
     }
     if (idProperty != null) {
       // load the id property
@@ -36,9 +36,9 @@ public final class CachedBeanDataToBean {
   }
 
   private static void loadProperty(EntityBean bean, CachedBeanData cacheBeanData, EntityBeanIntercept ebi, BeanProperty prop, PersistenceContext context) {
-    if (cacheBeanData.isLoaded(prop.getName())) {
-      if (!ebi.isLoadedProperty(prop.getPropertyIndex())) {
-        Object value = cacheBeanData.getData(prop.getName());
+    if (cacheBeanData.isLoaded(prop.name())) {
+      if (!ebi.isLoadedProperty(prop.propertyIndex())) {
+        Object value = cacheBeanData.getData(prop.name());
         prop.setCacheDataValue(bean, value, context);
       }
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultCacheAdapter.java b/ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultCacheAdapter.java
index 413af049d..e9b3752d6 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultCacheAdapter.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultCacheAdapter.java
@@ -27,7 +27,7 @@ public final class DefaultCacheAdapter implements ServerCacheManager {
   }
 
   @Override
-  public boolean isLocalL2Caching() {
+  public boolean localL2Caching() {
     return cacheManager.isLocalL2Caching();
   }
 
@@ -37,37 +37,37 @@ public final class DefaultCacheAdapter implements ServerCacheManager {
   }
 
   @Override
-  public void setEnabledRegions(String regions) {
+  public void enabledRegions(String regions) {
     cacheManager.setEnabledRegions(regions);
   }
 
   @Override
-  public ServerCacheRegion getRegion(String region) {
+  public ServerCacheRegion region(String region) {
     return cacheManager.getRegion(region);
   }
 
   @Override
-  public void setAllRegionsEnabled(boolean enabled) {
+  public void allRegionsEnabled(boolean enabled) {
     cacheManager.setAllRegionsEnabled(enabled);
   }
 
   @Override
-  public ServerCache getNaturalKeyCache(Class<?> beanType) {
+  public ServerCache naturalKeyCache(Class<?> beanType) {
     return cacheManager.getNaturalKeyCache(beanType);
   }
 
   @Override
-  public ServerCache getBeanCache(Class<?> beanType) {
+  public ServerCache beanCache(Class<?> beanType) {
     return cacheManager.getBeanCache(beanType);
   }
 
   @Override
-  public ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName) {
+  public ServerCache collectionIdsCache(Class<?> beanType, String propertyName) {
     return cacheManager.getCollectionIdsCache(beanType, propertyName);
   }
 
   @Override
-  public ServerCache getQueryCache(Class<?> beanType) {
+  public ServerCache queryCache(Class<?> beanType) {
     return cacheManager.getQueryCache(beanType);
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultServerCacheManager.java b/ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultServerCacheManager.java
index 562a98371..d3a652437 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultServerCacheManager.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultServerCacheManager.java
@@ -65,17 +65,17 @@ public final class DefaultServerCacheManager implements SpiCacheManager {
       List<String> enabled = new ArrayList<>();
 
       for (SpiCacheRegion region : regionMap.values()) {
-        if (enabledRegionNames.contains(region.getName())) {
-          enabled.add(region.getName());
+        if (enabledRegionNames.contains(region.name())) {
+          enabled.add(region.name());
           if (!region.isEnabled()) {
             region.setEnabled(true);
-            log.debug("Cache region[{}] enabled", region.getName());
+            log.debug("Cache region[{}] enabled", region.name());
           }
         } else {
-          disabled.add(region.getName());
+          disabled.add(region.name());
           if (region.isEnabled()) {
             region.setEnabled(false);
-            log.debug("Cache region[{}] disabled", region.getName());
+            log.debug("Cache region[{}] disabled", region.name());
           }
         }
       }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/changelog/DefaultChangeLogListener.java b/ebean-core/src/main/java/io/ebeaninternal/server/changelog/DefaultChangeLogListener.java
index 6e12aa31d..5cda1ed36 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/changelog/DefaultChangeLogListener.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/changelog/DefaultChangeLogListener.java
@@ -46,7 +46,7 @@ public final class DefaultChangeLogListener implements ChangeLogListener, Plugin
   @Override
   public void configure(SpiServer server) {
     jsonBuilder = new ChangeJsonBuilder();
-    Properties properties = server.getServerConfig().getProperties();
+    Properties properties = server.config().getProperties();
     if (properties != null) {
       String bufferSize = properties.getProperty("ebean.changeLog.bufferSize");
       if (bufferSize != null) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/cluster/ClusterManager.java b/ebean-core/src/main/java/io/ebeaninternal/server/cluster/ClusterManager.java
index d2bdaeda7..a85444486 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/cluster/ClusterManager.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/cluster/ClusterManager.java
@@ -56,7 +56,7 @@ public class ClusterManager implements ServerLookup {
   public void registerServer(EbeanServer server) {
     lock.lock();
     try {
-      serverMap.put(server.getName(), server);
+      serverMap.put(server.name(), server);
       if (!started) {
         startup();
       }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/AbstractSqlQueryRequest.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/AbstractSqlQueryRequest.java
index a88f1bbe9..f11cf9f8e 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/AbstractSqlQueryRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/AbstractSqlQueryRequest.java
@@ -121,7 +121,7 @@ public abstract class AbstractSqlQueryRequest implements CancelableQuery {
     int firstRow = query.getFirstRow();
     int maxRows = query.getMaxRows();
     if (firstRow > 0 || maxRows > 0) {
-      return server.getDatabasePlatform().getBasicSqlLimiter().limit(sql, firstRow, maxRows);
+      return server.databasePlatform().getBasicSqlLimiter().limit(sql, firstRow, maxRows);
     }
     return sql;
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/BeanRequest.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/BeanRequest.java
index 74327b5f2..0bec5a5a5 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/BeanRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/BeanRequest.java
@@ -14,21 +14,13 @@ public abstract class BeanRequest {
 
   static final Logger log = LoggerFactory.getLogger(BeanRequest.class);
 
-  /**
-   * The server processing the request.
-   */
-  protected final SpiEbeanServer ebeanServer;
-
-  /**
-   * The transaction this is part of.
-   */
+  protected final SpiEbeanServer server;
   protected SpiTransaction transaction;
-
   protected boolean createdTransaction;
 
-  public BeanRequest(SpiEbeanServer ebeanServer, SpiTransaction t) {
-    this.ebeanServer = ebeanServer;
-    this.transaction = t;
+  public BeanRequest(SpiEbeanServer server, SpiTransaction transaction) {
+    this.server = server;
+    this.transaction = transaction;
   }
 
   /**
@@ -36,7 +28,6 @@ public abstract class BeanRequest {
    * <p>
    * A transaction may have been passed in or active in the thread local. If
    * not then create one implicitly to handle the request.
-   * </p>
    *
    * @return True if a transaction was set (from current or created).
    */
@@ -44,10 +35,10 @@ public abstract class BeanRequest {
     if (transaction != null) {
       return false;
     }
-    transaction = ebeanServer.currentServerTransaction();
+    transaction = server.currentServerTransaction();
     if (transaction == null || !transaction.isActive()) {
       // create an implicit transaction to execute this query
-      transaction = ebeanServer.beginServerTransaction();
+      transaction = server.beginServerTransaction();
       createdTransaction = true;
     }
     return true;
@@ -58,7 +49,7 @@ public abstract class BeanRequest {
    */
   public void commitTransIfRequired() {
     if (createdTransaction) {
-      ebeanServer.commitTransaction();
+      server.commitTransaction();
     }
   }
 
@@ -68,7 +59,7 @@ public abstract class BeanRequest {
   public void rollbackTransIfRequired() {
     if (createdTransaction) {
       try {
-        ebeanServer.endTransaction();
+        server.endTransaction();
       } catch (Exception e) {
         // Just log this and carry on. A previous exception has been
         // thrown and if this rollback throws exception it likely means
@@ -83,7 +74,7 @@ public abstract class BeanRequest {
    */
   public void clearTransIfRequired() {
     if (createdTransaction) {
-      ebeanServer.clearServerTransaction();
+      server.clearServerTransaction();
     }
   }
 
@@ -92,45 +83,45 @@ public abstract class BeanRequest {
    * BeanController and BeanFinder.
    */
   public EbeanServer getEbeanServer() {
-    return ebeanServer;
+    return server;
   }
 
-  public SpiEbeanServer getServer() {
-    return ebeanServer;
+  public SpiEbeanServer server() {
+    return server;
   }
 
   /**
    * Return the Transaction associated with this request.
    */
-  public SpiTransaction getTransaction() {
+  public SpiTransaction transaction() {
     return transaction;
   }
 
   /**
    * Set the transaction to use for this request.
    */
-  public void setTransaction(SpiTransaction transaction) {
+  public void transaction(SpiTransaction transaction) {
     this.transaction = transaction;
   }
 
   /**
    * Return true if SQL should be logged for this transaction.
    */
-  public boolean isLogSql() {
+  public boolean logSql() {
     return transaction.isLogSql();
   }
 
   /**
    * Return true if SUMMARY information should be logged for this transaction.
    */
-  public boolean isLogSummary() {
+  public boolean logSummary() {
     return transaction.isLogSummary();
   }
 
   /**
    * Return the DataTimeZone to use.
    */
-  public DataTimeZone getDataTimeZone() {
-    return ebeanServer.getDataTimeZone();
+  public DataTimeZone dataTimeZone() {
+    return server.dataTimeZone();
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DScriptRunner.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DScriptRunner.java
index cb78076bc..2b4c81f0b 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DScriptRunner.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DScriptRunner.java
@@ -26,7 +26,7 @@ final class DScriptRunner implements ScriptRunner {
 
   DScriptRunner(SpiEbeanServer server) {
     this.server = server;
-    this.platformName = this.server.getDatabasePlatform().getPlatform().base().name();
+    this.platformName = this.server.platform().base().name();
   }
 
   @Override
@@ -102,7 +102,7 @@ final class DScriptRunner implements ScriptRunner {
 
   private Connection obtainConnection() {
     try {
-      return server.getDataSource().getConnection();
+      return server.dataSource().getConnection();
     } catch (SQLException e) {
       throw new PersistenceException("Failed to obtain connection to run script", e);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanLoader.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanLoader.java
index 4d0409d4c..826f3a15f 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanLoader.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanLoader.java
@@ -35,19 +35,16 @@ final class DefaultBeanLoader {
 
   DefaultBeanLoader(DefaultServer server) {
     this.server = server;
-    this.onIterateUseExtraTxn = server.getDatabasePlatform().useExtraTransactionOnIterateSecondaryQueries();
+    this.onIterateUseExtraTxn = server.databasePlatform().useExtraTransactionOnIterateSecondaryQueries();
   }
 
   void loadMany(LoadManyRequest loadRequest) {
-    SpiQuery<?> query = loadRequest.createQuery(server);
-    executeQuery(loadRequest, query);
+    executeQuery(loadRequest, loadRequest.createQuery(server));
     loadRequest.postLoad();
   }
 
   void loadMany(BeanCollection<?> bc, boolean onlyIds) {
-    EntityBean parentBean = bc.getOwnerBean();
-    String propertyName = bc.getPropertyName();
-    loadManyInternal(parentBean, propertyName, null, false, onlyIds);
+    loadManyInternal(bc.getOwnerBean(), bc.getPropertyName(), null, false, onlyIds);
   }
 
   void refreshMany(EntityBean parentBean, String propertyName) {
@@ -57,8 +54,8 @@ final class DefaultBeanLoader {
   private void loadManyInternal(EntityBean parentBean, String propertyName, Transaction t, boolean refresh, boolean onlyIds) {
     EntityBeanIntercept ebi = parentBean._ebean_getIntercept();
     PersistenceContext pc = ebi.getPersistenceContext();
-    BeanDescriptor<?> parentDesc = server.getBeanDescriptor(parentBean.getClass());
-    BeanPropertyAssocMany<?> many = (BeanPropertyAssocMany<?>) parentDesc.getBeanProperty(propertyName);
+    BeanDescriptor<?> parentDesc = server.descriptor(parentBean.getClass());
+    BeanPropertyAssocMany<?> many = (BeanPropertyAssocMany<?>) parentDesc.beanProperty(propertyName);
     BeanCollection<?> beanCollection = null;
     ExpressionList<?> filterMany = null;
 
@@ -69,12 +66,10 @@ final class DefaultBeanLoader {
     }
 
     Object parentId = parentDesc.getId(parentBean);
-
     if (pc == null) {
       pc = new DefaultPersistenceContext();
       parentDesc.contextPut(pc, parentId, parentBean);
     }
-
     boolean useManyIdCache = beanCollection != null && parentDesc.isManyPropCaching() && many.isUseCache();
     if (useManyIdCache) {
       Boolean readOnly = null;
@@ -86,8 +81,7 @@ final class DefaultBeanLoader {
       }
     }
 
-    SpiQuery<?> query = server.createQuery(parentDesc.getBeanType());
-
+    SpiQuery<?> query = server.createQuery(parentDesc.type());
     if (refresh) {
       // populate a new collection
       BeanCollection<?> emptyCollection = many.createEmpty(parentBean);
@@ -97,23 +91,21 @@ final class DefaultBeanLoader {
       query.setLoadDescription("+lazy", null);
     }
 
-    query.select(parentDesc.getIdBinder().getIdProperty());
-
+    query.select(parentDesc.idBinder().getIdProperty());
     if (onlyIds) {
-      query.fetch(many.getName(), many.getTargetIdProperty());
+      query.fetch(many.name(), many.targetIdProperty());
     } else {
-      query.fetch(many.getName());
+      query.fetch(many.name());
     }
     if (filterMany != null) {
-      query.setFilterMany(many.getName(), filterMany);
+      query.setFilterMany(many.name(), filterMany);
     }
 
     query.where().idEq(parentId);
-    query.setUseCache(false);
+    query.setBeanCacheMode(CacheMode.OFF);
     query.setMode(Mode.LAZYLOAD_MANY);
-    query.setLazyLoadManyPath(many.getName());
+    query.setLazyLoadManyPath(many.name());
     query.setPersistenceContext(pc);
-
     if (ebi.isReadOnly()) {
       query.setReadOnly(true);
     }
@@ -134,7 +126,7 @@ final class DefaultBeanLoader {
    * Load a batch of beans for +query or +lazy loading.
    */
   void loadBean(LoadBeanRequest loadRequest) {
-    List<EntityBeanIntercept> batch = loadRequest.getBatch();
+    List<EntityBeanIntercept> batch = loadRequest.batch();
     if (batch.isEmpty()) {
       throw new RuntimeException("Nothing in batch?");
     }
@@ -145,12 +137,8 @@ final class DefaultBeanLoader {
       return;
     }
 
-    SpiQuery<?> query = server.createQuery(loadRequest.getBeanType());
+    SpiQuery<?> query = server.createQuery(loadRequest.beanType());
     loadRequest.configureQuery(query, idList);
-    if (loadRequest.isLoadedFromCache()) {
-      query.setBeanCacheMode(CacheMode.PUT);
-    }
-
     List<?> list = executeQuery(loadRequest, query);
     loadRequest.postLoad(list);
   }
@@ -168,7 +156,7 @@ final class DefaultBeanLoader {
         extraTxn.end();
       }
     } else {
-      return server.findList(query, loadRequest.getTransaction());
+      return server.findList(query, loadRequest.transaction());
     }
   }
 
@@ -188,12 +176,11 @@ final class DefaultBeanLoader {
       pc = null;
     }
 
-    BeanDescriptor<?> desc = server.getBeanDescriptor(bean.getClass());
-    if (EntityType.EMBEDDED == desc.getEntityType()) {
+    BeanDescriptor<?> desc = server.descriptor(bean.getClass());
+    if (EntityType.EMBEDDED == desc.entityType()) {
       // lazy loading on an embedded bean property
       EntityBean embeddedOwner = (EntityBean) ebi.getEmbeddedOwner();
-      int ownerIndex = ebi.getEmbeddedOwnerIndex();
-      refreshBeanInternal(embeddedOwner, mode, ownerIndex);
+      refreshBeanInternal(embeddedOwner, mode, ebi.getEmbeddedOwnerIndex());
     }
 
     Object id = desc.getId(bean);
@@ -216,7 +203,7 @@ final class DefaultBeanLoader {
       }
     }
 
-    SpiQuery<?> query = server.createQuery(desc.getBeanType());
+    SpiQuery<?> query = server.createQuery(desc.type());
     query.setLazyLoadProperty(ebi.getLazyLoadProperty());
     if (draft) {
       query.asDraft();
@@ -235,7 +222,7 @@ final class DefaultBeanLoader {
     query.setId(id);
     if (embeddedOwnerIndex > -1 || mode == Mode.REFRESH_BEAN) {
       // make sure the query doesn't use the cache
-      query.setUseCache(false);
+      query.setBeanCacheMode(CacheMode.OFF);
     }
     if (ebi.isReadOnly()) {
       query.setReadOnly(true);
@@ -249,8 +236,7 @@ final class DefaultBeanLoader {
 
     Object dbBean = query.findOne();
     if (dbBean == null) {
-      String msg = "Bean not found during lazy load or refresh." + " id[" + id + "] type[" + desc.getBeanType() + "]";
-      throw new EntityNotFoundException(msg);
+      throw new EntityNotFoundException("Bean not found during lazy load or refresh." + " id[" + id + "] type[" + desc.type() + "]");
     }
     desc.resetManyProperties(dbBean);
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanState.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanState.java
index 5bedf1355..725fe75e1 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanState.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanState.java
@@ -45,17 +45,17 @@ public final class DefaultBeanState implements BeanState {
   }
 
   @Override
-  public Set<String> getLoadedProps() {
+  public Set<String> loadedProps() {
     return intercept.getLoadedPropertyNames();
   }
 
   @Override
-  public Set<String> getChangedProps() {
+  public Set<String> changedProps() {
     return intercept.getDirtyPropertyNames();
   }
 
   @Override
-  public Map<String, ValuePair> getDirtyValues() {
+  public Map<String, ValuePair> dirtyValues() {
     return intercept.getDirtyValues();
   }
 
@@ -90,12 +90,12 @@ public final class DefaultBeanState implements BeanState {
   }
 
   @Override
-  public Map<String, Exception> getLoadErrors() {
+  public Map<String, Exception> loadErrors() {
     return intercept.getLoadErrors();
   }
 
   @Override
-  public int getSortOrder() {
+  public int sortOrder() {
     return intercept.getSortOrder();
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultCallableSql.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultCallableSql.java
index fe7b18392..50807aa64 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultCallableSql.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultCallableSql.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.core;
 
 import io.ebean.CallableSql;
-import io.ebean.EbeanServer;
+import io.ebean.Database;
 import io.ebeaninternal.api.BindParams;
 import io.ebeaninternal.api.BindParams.Param;
 import io.ebeaninternal.api.SpiCallableSql;
@@ -9,39 +9,23 @@ import io.ebeaninternal.api.TransactionEventTable;
 
 import java.io.Serializable;
 import java.sql.CallableStatement;
-import java.sql.SQLException;
 
-
-public final class DefaultCallableSql implements Serializable, SpiCallableSql {
+final class DefaultCallableSql implements Serializable, SpiCallableSql {
 
   private static final long serialVersionUID = 8984272253185424701L;
 
-  private transient final EbeanServer server;
-
-  /**
-   * The callable sql.
-   */
-  private String sql;
-
-  /**
-   * To display in the transaction log to help identify the procedure.
-   */
-  private String label;
-
-  private int timeout;
-
   /**
    * Holds the table modification information. On commit this information is
    * used to manage the cache etc.
    */
   private final TransactionEventTable transactionEvent = new TransactionEventTable();
-
   private final BindParams bindParameters = new BindParams();
+  private transient final Database server;
+  private String sql;
+  private String label;
+  private int timeout;
 
-  /**
-   * Create with callable sql.
-   */
-  public DefaultCallableSql(EbeanServer server, String sql) {
+  DefaultCallableSql(Database server, String sql) {
     this.server = server;
     this.sql = sql;
   }
@@ -108,13 +92,12 @@ public final class DefaultCallableSql implements Serializable, SpiCallableSql {
   }
 
   @Override
-  public boolean executeOverride(CallableStatement cstmt) throws SQLException {
+  public boolean executeOverride(CallableStatement statement) {
     return false;
   }
 
   @Override
   public CallableSql addModification(String tableName, boolean inserts, boolean updates, boolean deletes) {
-
     transactionEvent.add(tableName, inserts, updates, deletes);
     return this;
   }
@@ -122,7 +105,7 @@ public final class DefaultCallableSql implements Serializable, SpiCallableSql {
   /**
    * Return the TransactionEvent which holds the table modification
    * information for this CallableSql. This information is merged into the
-   * transaction after the transaction is commited.
+   * transaction after the transaction is committed.
    */
   @Override
   public TransactionEventTable getTransactionEventTable() {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultQueryPlanListener.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultQueryPlanListener.java
index ba2e99bda..5a6196230 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultQueryPlanListener.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultQueryPlanListener.java
@@ -15,7 +15,7 @@ final class DefaultQueryPlanListener implements QueryPlanListener {
   @Override
   public void process(QueryPlanCapture capture) {
     // better to log this in JSON form?
-    String dbName = capture.getDatabase().getName();
+    String dbName = capture.getDatabase().name();
     for (MetaQueryPlan plan : capture.getPlans()) {
       log.info("queryPlan  db:{} label:{} queryTimeMicros:{} loc:{} sql:{} bind:{} plan:{}",
         dbName, plan.label(), plan.queryTimeMicros(), plan.profileLocation(),
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultServer.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultServer.java
index 1c77e06a8..0e293d37d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultServer.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultServer.java
@@ -129,16 +129,7 @@ import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.time.Clock;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.Spliterator;
+import java.util.*;
 import java.util.concurrent.Callable;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
@@ -295,7 +286,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public int getLazyLoadBatchSize() {
+  public int lazyLoadBatchSize() {
     return lazyLoadBatchSize;
   }
 
@@ -305,12 +296,12 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public DatabaseConfig getServerConfig() {
+  public DatabaseConfig config() {
     return config;
   }
 
   @Override
-  public DatabasePlatform getDatabasePlatform() {
+  public DatabasePlatform databasePlatform() {
     return databasePlatform;
   }
 
@@ -320,57 +311,57 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public DataTimeZone getDataTimeZone() {
+  public DataTimeZone dataTimeZone() {
     return dataTimeZone;
   }
 
   @Override
-  public MetaInfoManager getMetaInfoManager() {
+  public MetaInfoManager metaInfo() {
     return metaInfoManager;
   }
 
   @Override
-  public Platform getPlatform() {
+  public Platform platform() {
     return databasePlatform.getPlatform();
   }
 
   @Override
-  public SpiServer getPluginApi() {
+  public SpiServer pluginApi() {
     return this;
   }
 
   @Override
-  public BackgroundExecutor getBackgroundExecutor() {
+  public BackgroundExecutor backgroundExecutor() {
     return backgroundExecutor;
   }
 
   @Override
-  public ExpressionFactory getExpressionFactory() {
+  public ExpressionFactory expressionFactory() {
     return expressionFactory;
   }
 
   @Override
-  public AutoTune getAutoTune() {
+  public AutoTune autoTune() {
     return autoTuneService;
   }
 
   @Override
-  public DataSource getDataSource() {
+  public DataSource dataSource() {
     return transactionManager.getDataSource();
   }
 
   @Override
-  public DataSource getReadOnlyDataSource() {
+  public DataSource readOnlyDataSource() {
     return transactionManager.getReadOnlyDataSource();
   }
 
   @Override
-  public ReadAuditPrepare getReadAuditPrepare() {
+  public ReadAuditPrepare readAuditPrepare() {
     return readAuditPrepare;
   }
 
   @Override
-  public ReadAuditLogger getReadAuditLogger() {
+  public ReadAuditLogger readAuditLogger() {
     return readAuditLogger;
   }
 
@@ -381,7 +372,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     if (encryptKeyManager != null) {
       encryptKeyManager.initialise();
     }
-    serverCacheManager.setEnabledRegions(config.getEnabledL2Regions());
+    serverCacheManager.enabledRegions(config.getEnabledL2Regions());
   }
 
   /**
@@ -499,7 +490,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    * Return the server name.
    */
   @Override
-  public String getName() {
+  public String name() {
     return serverName;
   }
 
@@ -519,7 +510,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public BeanState getBeanState(Object bean) {
+  public BeanState beanState(Object bean) {
     if (bean instanceof EntityBean) {
       return new DefaultBeanState((EntityBean) bean);
     }
@@ -538,7 +529,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public ServerCacheManager getServerCacheManager() {
+  public ServerCacheManager cacheManager() {
     return serverCacheManager;
   }
 
@@ -595,7 +586,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     if (a == null) {
       return null;
     }
-    BeanDescriptor<?> desc = getBeanDescriptor(a.getClass());
+    BeanDescriptor<?> desc = descriptor(a.getClass());
     return DiffHelp.diff(a, b, desc);
   }
 
@@ -628,14 +619,14 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   public void truncate(Class<?>... types) {
     List<String> tableNames = new ArrayList<>();
     for (Class<?> type : types) {
-      tableNames.add(getBeanDescriptor(type).getBaseTable());
+      tableNames.add(descriptor(type).baseTable());
     }
     truncate(tableNames.toArray(new String[0]));
   }
 
   @Override
   public void truncate(String... tables) {
-    try (Connection connection = getDataSource().getConnection()) {
+    try (Connection connection = dataSource().getConnection()) {
       for (String table : tables) {
         executeSql(connection, databasePlatform.truncateStatement(table));
       }
@@ -659,7 +650,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    */
   @Override
   public void clearQueryStatistics() {
-    for (BeanDescriptor<?> desc : getBeanDescriptors()) {
+    for (BeanDescriptor<?> desc : descriptors()) {
       desc.clearQueryStatistics();
     }
   }
@@ -674,7 +665,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    */
   @Override
   public <T> T createEntityBean(Class<T> type) {
-    return getBeanDescriptor(type).createBean();
+    return descriptor(type).createBean();
   }
 
   /**
@@ -687,11 +678,11 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    */
   @Override
   @SuppressWarnings({"unchecked", "rawtypes"})
-  public <T> T getReference(Class<T> type, Object id) {
+  public <T> T reference(Class<T> type, Object id) {
     if (id == null) {
       throw new NullPointerException("The id is null");
     }
-    BeanDescriptor desc = getBeanDescriptor(type);
+    BeanDescriptor desc = descriptor(type);
     id = desc.convertId(id);
     PersistenceContext pc = null;
     SpiTransaction t = transactionManager.getActive();
@@ -703,17 +694,17 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
       }
     }
 
-    InheritInfo inheritInfo = desc.getInheritInfo();
+    InheritInfo inheritInfo = desc.inheritInfo();
     if (inheritInfo == null || inheritInfo.isConcrete()) {
       return (T) desc.contextRef(pc, null, false, id);
     }
-    BeanProperty idProp = desc.getIdProperty();
+    BeanProperty idProp = desc.idProperty();
     if (idProp == null) {
       throw new PersistenceException("No ID properties for this type? " + desc);
     }
     // we actually need to do a query because we don't know the type without the discriminator
     // value, just select the id property and discriminator column (auto added)
-    return find(type).select(idProp.getName()).setId(id).findOne();
+    return find(type).select(idProp.name()).setId(id).findOne();
   }
 
   @Override
@@ -852,7 +843,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public Object nextId(Class<?> beanType) {
-    BeanDescriptor<?> desc = getBeanDescriptor(beanType);
+    BeanDescriptor<?> desc = descriptor(beanType);
     return desc.nextId(null);
   }
 
@@ -871,7 +862,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     }
     // use first bean in the list as the correct type
     Class<T> beanType = (Class<T>) list.get(0).getClass();
-    BeanDescriptor<T> beanDescriptor = getBeanDescriptor(beanType);
+    BeanDescriptor<T> beanDescriptor = descriptor(beanType);
     if (beanDescriptor == null) {
       throw new PersistenceException("BeanDescriptor not found, is [" + beanType + "] an entity bean?");
     }
@@ -880,7 +871,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public <T> Set<String> validateQuery(Query<T> query) {
-    BeanDescriptor<T> beanDescriptor = getBeanDescriptor(query.getBeanType());
+    BeanDescriptor<T> beanDescriptor = descriptor(query.getBeanType());
     if (beanDescriptor == null) {
       throw new PersistenceException("BeanDescriptor not found, is [" + query.getBeanType() + "] an entity bean?");
     }
@@ -889,7 +880,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public <T> Filter<T> filter(Class<T> beanType) {
-    BeanDescriptor<T> desc = getBeanDescriptor(beanType);
+    BeanDescriptor<T> desc = descriptor(beanType);
     if (desc == null) {
       String m = beanType.getName() + " is NOT an Entity Bean registered with this server?";
       throw new PersistenceException(m);
@@ -899,7 +890,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public <T> CsvReader<T> createCsvReader(Class<T> beanType) {
-    BeanDescriptor<T> descriptor = getBeanDescriptor(beanType);
+    BeanDescriptor<T> descriptor = descriptor(beanType);
     if (descriptor == null) {
       throw new NullPointerException("BeanDescriptor for " + beanType.getName() + " not found");
     }
@@ -923,13 +914,27 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public void merge(Object bean, MergeOptions options, Transaction transaction) {
-    BeanDescriptor<?> desc = getBeanDescriptor(bean.getClass());
+    BeanDescriptor<?> desc = descriptor(bean.getClass());
     if (desc == null) {
       throw new PersistenceException(bean.getClass().getName() + " is NOT an Entity Bean registered with this server?");
     }
     executeInTrans((txn) -> persister.merge(desc, checkEntityBean(bean), options, txn), transaction);
   }
 
+  @Override
+  public void lock(Object bean) {
+    BeanDescriptor<?> desc = descriptor(bean.getClass());
+    if (desc == null) {
+      throw new PersistenceException(bean.getClass() + " is NOT an Entity Bean registered with this server?");
+    }
+    Object id = desc.id(bean);
+    Objects.requireNonNull(id, "Bean missing an @Id value which is required to lock");
+    new DefaultOrmQuery<>(desc, this, expressionFactory)
+      .setId(id)
+      .withLock(Query.LockType.DEFAULT, Query.LockWait.NOWAIT)
+      .findOne();
+  }
+
   @Override
   public <T> Query<T> find(Class<T> beanType) {
     return createQuery(beanType);
@@ -937,7 +942,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public <T> Query<T> findNative(Class<T> beanType, String nativeSql) {
-    BeanDescriptor<T> desc = getBeanDescriptor(beanType);
+    BeanDescriptor<T> desc = descriptor(beanType);
     if (desc == null) {
       throw new PersistenceException(beanType.getName() + " is NOT an Entity Bean registered with this server?");
     }
@@ -948,15 +953,15 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery) {
-    BeanDescriptor<T> desc = getBeanDescriptor(beanType);
+    BeanDescriptor<T> desc = descriptor(beanType);
     if (desc == null) {
       throw new PersistenceException(beanType.getName() + " is NOT an Entity Bean registered with this server?");
     }
-    String named = desc.getNamedQuery(namedQuery);
+    String named = desc.namedQuery(namedQuery);
     if (named != null) {
       return createQuery(beanType, named);
     }
-    SpiRawSql rawSql = desc.getNamedRawSql(namedQuery);
+    SpiRawSql rawSql = desc.namedRawSql(namedQuery);
     if (rawSql != null) {
       DefaultOrmQuery<T> query = createQuery(beanType);
       query.setRawSql(rawSql);
@@ -974,7 +979,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public <T> DefaultOrmQuery<T> createQuery(Class<T> beanType) {
-    BeanDescriptor<T> desc = getBeanDescriptor(beanType);
+    BeanDescriptor<T> desc = descriptor(beanType);
     if (desc == null) {
       throw new PersistenceException(beanType.getName() + " is NOT an Entity Bean registered with this server?");
     }
@@ -983,12 +988,12 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public <T> Update<T> createUpdate(Class<T> beanType, String ormUpdate) {
-    BeanDescriptor<?> desc = getBeanDescriptor(beanType);
+    BeanDescriptor<?> desc = descriptor(beanType);
     if (desc == null) {
       String m = beanType.getName() + " is NOT an Entity Bean registered with this server?";
       throw new PersistenceException(m);
     }
-    return new DefaultOrmUpdate<>(beanType, this, desc.getBaseTable(), ormUpdate);
+    return new DefaultOrmUpdate<>(beanType, this, desc.baseTable(), ormUpdate);
   }
 
   @Override
@@ -1134,14 +1139,14 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    * Return true if transactions PersistenceContext should be used.
    */
   private <T> boolean useTransactionPersistenceContext(SpiQuery<T> query) {
-    return PersistenceContextScope.TRANSACTION == getPersistenceContextScope(query);
+    return PersistenceContextScope.TRANSACTION == persistenceContextScope(query);
   }
 
   /**
    * Return the PersistenceContextScope to use defined at query or server level.
    */
   @Override
-  public PersistenceContextScope getPersistenceContextScope(SpiQuery<?> query) {
+  public PersistenceContextScope persistenceContextScope(SpiQuery<?> query) {
     PersistenceContextScope scope = query.getPersistenceContextScope();
     return (scope != null) ? scope : defaultPersistenceContextScope;
   }
@@ -1227,7 +1232,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     request.resetBeanCacheAutoMode(false);
     if ((t == null || !t.isSkipCache()) && request.getFromBeanCache()) {
       // hit bean cache and got all results from cache
-      return request.getBeanCacheHitsAsMap();
+      return request.beanCacheHitsAsMap();
     }
     Object result = request.getFromQueryCache();
     if (result != null) {
@@ -1312,7 +1317,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     SpiOrmQueryRequest<?> request = createQueryRequest(Type.ID_LIST, query, t);
     Object result = request.getFromQueryCache();
     if (result != null) {
-      if (Boolean.FALSE.equals(request.getQuery().isReadOnly())) {
+      if (Boolean.FALSE.equals(request.query().isReadOnly())) {
         return new CopyOnFirstWriteList<>((List<A>) result);
       } else {
         return (List<A>) result;
@@ -1341,7 +1346,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
         if (ids.isEmpty()) {
           return 0;
         } else {
-          return persister.deleteByIds(request.getBeanDescriptor(), ids, request.getTransaction(), false);
+          return persister.deleteByIds(request.descriptor(), ids, request.transaction(), false);
         }
       }
     } finally {
@@ -1391,7 +1396,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     // FutureList query always run in it's own persistence content
     spiQuery.setPersistenceContext(new DefaultPersistenceContext());
     if (!spiQuery.isDisableReadAudit()) {
-      BeanDescriptor<T> desc = beanDescriptorManager.getBeanDescriptor(spiQuery.getBeanType());
+      BeanDescriptor<T> desc = beanDescriptorManager.descriptor(spiQuery.getBeanType());
       desc.readAuditFutureList(spiQuery);
     }
     // Create a new transaction solely to execute the findList() at some future time
@@ -1504,7 +1509,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     request.resetBeanCacheAutoMode(findOne);
     if ((t == null || !t.isSkipCache()) && request.getFromBeanCache()) {
       // hit bean cache and got all results from cache
-      return request.getBeanCacheHits();
+      return request.beanCacheHits();
     }
     request.prepareQuery();
     Object result = request.getFromQueryCache();
@@ -2048,26 +2053,26 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    * Return all the BeanDescriptors.
    */
   @Override
-  public List<BeanDescriptor<?>> getBeanDescriptors() {
-    return beanDescriptorManager.getBeanDescriptorList();
+  public List<BeanDescriptor<?>> descriptors() {
+    return beanDescriptorManager.descriptorList();
   }
 
   /**
    * Return the transaction manager.
    */
   @Override
-  public SpiTransactionManager getTransactionManager() {
+  public SpiTransactionManager transactionManager() {
     return transactionManager;
   }
 
   public void register(BeanPersistController controller) {
-    for (BeanDescriptor<?> desc : beanDescriptorManager.getBeanDescriptorList()) {
+    for (BeanDescriptor<?> desc : beanDescriptorManager.descriptorList()) {
       desc.register(controller);
     }
   }
 
   public void deregister(BeanPersistController c) {
-    for (BeanDescriptor<?> desc : beanDescriptorManager.getBeanDescriptorList()) {
+    for (BeanDescriptor<?> desc : beanDescriptorManager.descriptorList()) {
       desc.deregister(c);
     }
   }
@@ -2075,13 +2080,13 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   @Override
   public boolean isSupportedType(java.lang.reflect.Type genericType) {
     TypeInfo typeInfo = ParamTypeHelper.getTypeInfo(genericType);
-    return typeInfo != null && getBeanDescriptor(typeInfo.getBeanType()) != null;
+    return typeInfo != null && descriptor(typeInfo.getBeanType()) != null;
   }
 
   @Override
-  public Object setBeanId(Object bean, Object id) {
+  public Object beanId(Object bean, Object id) {
     EntityBean eb = checkEntityBean(bean);
-    BeanDescriptor<?> desc = getBeanDescriptor(bean.getClass());
+    BeanDescriptor<?> desc = descriptor(bean.getClass());
     if (desc == null) {
       throw new PersistenceException(bean.getClass().getName() + " is NOT an Entity Bean registered with this server?");
     }
@@ -2089,9 +2094,9 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public Object getBeanId(Object bean) {
+  public Object beanId(Object bean) {
     EntityBean eb = checkEntityBean(bean);
-    BeanDescriptor<?> desc = getBeanDescriptor(bean.getClass());
+    BeanDescriptor<?> desc = descriptor(bean.getClass());
     if (desc == null) {
       throw new PersistenceException(bean.getClass().getName() + " is NOT an Entity Bean registered with this server?");
     }
@@ -2102,58 +2107,58 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    * Return the BeanDescriptor for a given type of bean.
    */
   @Override
-  public <T> BeanDescriptor<T> getBeanDescriptor(Class<T> beanClass) {
-    return beanDescriptorManager.getBeanDescriptor(beanClass);
+  public <T> BeanDescriptor<T> descriptor(Class<T> beanClass) {
+    return beanDescriptorManager.descriptor(beanClass);
   }
 
   /**
    * Return the BeanDescriptor's for a given table name.
    */
   @Override
-  public List<BeanDescriptor<?>> getBeanDescriptors(String tableName) {
-    return beanDescriptorManager.getBeanDescriptors(tableName);
+  public List<BeanDescriptor<?>> descriptors(String tableName) {
+    return beanDescriptorManager.descriptors(tableName);
   }
 
   /**
    * Return all the SPI BeanTypes.
    */
   @Override
-  public List<? extends BeanType<?>> getBeanTypes() {
-    return getBeanDescriptors();
+  public List<? extends BeanType<?>> beanTypes() {
+    return descriptors();
   }
 
   /**
    * Return the SPI bean types mapped to the given table.
    */
   @Override
-  public List<? extends BeanType<?>> getBeanTypes(String tableName) {
-    return beanDescriptorManager.getBeanTypes(tableName);
+  public List<? extends BeanType<?>> beanTypes(String tableName) {
+    return beanDescriptorManager.beanTypes(tableName);
   }
 
   @Override
-  public BeanType<?> getBeanTypeForQueueId(String queueId) {
-    return getBeanDescriptorByQueueId(queueId);
+  public BeanType<?> beanTypeForQueueId(String queueId) {
+    return descriptorByQueueId(queueId);
   }
 
   @Override
-  public BeanDescriptor<?> getBeanDescriptorByQueueId(String queueId) {
-    return beanDescriptorManager.getBeanDescriptorByQueueId(queueId);
+  public BeanDescriptor<?> descriptorByQueueId(String queueId) {
+    return beanDescriptorManager.descriptorByQueueId(queueId);
   }
 
   /**
    * Return the SPI bean types for the given bean class.
    */
   @Override
-  public <T> BeanType<T> getBeanType(Class<T> beanType) {
-    return getBeanDescriptor(beanType);
+  public <T> BeanType<T> beanType(Class<T> beanType) {
+    return descriptor(beanType);
   }
 
   /**
    * Return the BeanDescriptor using its class name.
    */
   @Override
-  public BeanDescriptor<?> getBeanDescriptorById(String beanClassName) {
-    return beanDescriptorManager.getBeanDescriptorByClassName(beanClassName);
+  public BeanDescriptor<?> descriptorById(String beanClassName) {
+    return beanDescriptorManager.descriptorByClassName(beanClassName);
   }
 
   /**
@@ -2278,13 +2283,13 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   @Override
   public Set<Property> checkUniqueness(Object bean, Transaction transaction) {
     EntityBean entityBean = checkEntityBean(bean);
-    BeanDescriptor<?> beanDesc = getBeanDescriptor(entityBean.getClass());
-    BeanProperty idProperty = beanDesc.getIdProperty();
+    BeanDescriptor<?> beanDesc = descriptor(entityBean.getClass());
+    BeanProperty idProperty = beanDesc.idProperty();
     // if the ID of the Property is null we are unable to check uniqueness
     if (idProperty == null) {
       return Collections.emptySet();
     }
-    Object id = idProperty.getVal(entityBean);
+    Object id = idProperty.value(entityBean);
     if (entityBean._ebean_getIntercept().isNew() && id != null) {
       // Primary Key is changeable only on new models - so skip check if we are not new
       Query<?> query = new DefaultOrmQuery<>(beanDesc, this, expressionFactory);
@@ -2293,7 +2298,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
         return Collections.singleton(idProperty);
       }
     }
-    for (BeanProperty[] props : beanDesc.getUniqueProps()) {
+    for (BeanProperty[] props : beanDesc.uniqueProps()) {
       Set<Property> ret = checkUniqueness(entityBean, beanDesc, props, transaction);
       if (ret != null) {
         return ret;
@@ -2306,19 +2311,19 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    * Returns a set of properties if saving the bean will violate the unique constraints (defined by given properties).
    */
   private Set<Property> checkUniqueness(EntityBean entityBean, BeanDescriptor<?> beanDesc, BeanProperty[] props, Transaction transaction) {
-    BeanProperty idProperty = beanDesc.getIdProperty();
+    BeanProperty idProperty = beanDesc.idProperty();
     Query<?> query = new DefaultOrmQuery<>(beanDesc, this, expressionFactory);
     ExpressionList<?> exprList = query.where();
     if (!entityBean._ebean_getIntercept().isNew()) {
       // if model is not new, exclude ourself.
-      exprList.ne(idProperty.getName(), idProperty.getVal(entityBean));
+      exprList.ne(idProperty.name(), idProperty.value(entityBean));
     }
     for (Property prop : props) {
-      Object value = prop.getVal(entityBean);
+      Object value = prop.value(entityBean);
       if (value == null) {
         return null;
       }
-      exprList.eq(prop.getName(), value);
+      exprList.eq(prop.name(), value);
     }
     if (findCount(query, transaction) > 0) {
       Set<Property> ret = new LinkedHashSet<>();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultSqlUpdate.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultSqlUpdate.java
index c516e730e..8f66ae6eb 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultSqlUpdate.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultSqlUpdate.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.core;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.SqlUpdate;
 import io.ebean.Update;
 import io.ebeaninternal.api.BindParams;
@@ -143,7 +143,7 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
       return server.execute(this);
     } else {
       // Hopefully this doesn't catch anyone out...
-      return Ebean.execute(this);
+      return DB.getDefault().execute(this);
     }
   }
 
@@ -167,7 +167,6 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
     return server.executeBatch(this, transaction);
   }
 
-
   @Override
   public void addBatch() {
     if (server == null) {
@@ -179,7 +178,6 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
         throw new IllegalStateException("No current transaction? Must have a transaction to use addBatch()");
       }
     }
-
     batched = true;
     server.addBatch(this, transaction);
   }
@@ -287,8 +285,7 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
     return this;
   }
 
-  private SqlUpdate setParamWithBindExpansion(int position, Collection values, String bindLiteral) {
-
+  private SqlUpdate setParamWithBindExpansion(int position, Collection<?> values, String bindLiteral) {
     StringBuilder sqlExpand = new StringBuilder(values.size() * 2);
     position = position + bindExpansion;
     int offset = 0;
@@ -310,10 +307,9 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
       String bindLiteral = "?" + position;
       int pos = baseSql.indexOf(bindLiteral);
       if (pos > -1) {
-        return setParamWithBindExpansion(position, (Collection) value, bindLiteral);
+        return setParamWithBindExpansion(position, (Collection<?>) value, bindLiteral);
       }
     }
-
     bindParams.setParameter(bindExpansion + position, value);
     return this;
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DtoQueryRequest.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DtoQueryRequest.java
index c023f2d0d..58c5dae77 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DtoQueryRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DtoQueryRequest.java
@@ -66,7 +66,7 @@ public final class DtoQueryRequest<T> extends AbstractSqlQueryRequest {
   @Override
   protected void setResultSet(ResultSet resultSet, Object queryPlanKey) throws SQLException {
     this.resultSet = resultSet;
-    this.dataReader = new RsetDataReader(server.getDataTimeZone(), resultSet);
+    this.dataReader = new RsetDataReader(server.dataTimeZone(), resultSet);
     obtainPlan(queryPlanKey);
   }
 
@@ -114,6 +114,7 @@ public final class DtoQueryRequest<T> extends AbstractSqlQueryRequest {
     return queryEngine.findList(this);
   }
 
+  @Override
   public boolean next() throws SQLException {
     query.checkCancelled();
     return dataReader.next();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetrics.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetrics.java
index 9b5a1afa7..73ad97f2c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetrics.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetrics.java
@@ -73,8 +73,8 @@ final class DumpMetrics {
 
   void dump() {
 
-    out("-- Dumping metrics for " + server.getName() + " -- ");
-    ServerMetrics serverMetrics = server.getMetaInfoManager().collectMetrics();
+    out("-- Dumping metrics for " + server.name() + " -- ");
+    ServerMetrics serverMetrics = server.metaInfo().collectMetrics();
 
     for (MetaTimedMetric metric : serverMetrics.timedMetrics()) {
       log(metric);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetricsData.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetricsData.java
index 712521ce0..ef006949f 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetricsData.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetricsData.java
@@ -24,7 +24,7 @@ final class DumpMetricsData {
   }
 
   List<MetricData> data() {
-    collect(database.getMetaInfoManager().collectMetrics());
+    collect(database.metaInfo().collectMetrics());
     return list;
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetricsJson.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetricsJson.java
index 190af0af4..0b96dcbd9 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetricsJson.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetricsJson.java
@@ -66,14 +66,14 @@ final class DumpMetricsJson implements ServerMetricsAsJson {
   @Override
   public String json() {
     writer = new StringWriter();
-    collect(database.getMetaInfoManager().collectMetrics());
+    collect(database.metaInfo().collectMetrics());
     return writer.toString();
   }
 
   @Override
   public void write(Appendable buffer) {
     writer = buffer;
-    collect(database.getMetaInfoManager().collectMetrics());
+    collect(database.metaInfo().collectMetrics());
   }
 
   private void collect(ServerMetrics serverMetrics) {
@@ -112,7 +112,7 @@ final class DumpMetricsJson implements ServerMetricsAsJson {
     if (withHeader) {
       objStart();
       key("db");
-      val(database.getName());
+      val(database.name());
       key("metrics");
       listStart();
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/InternalConfiguration.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/InternalConfiguration.java
index 96ab21aa2..50410beb0 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/InternalConfiguration.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/InternalConfiguration.java
@@ -175,7 +175,7 @@ public final class InternalConfiguration {
     this.dtoBeanManager = new DtoBeanManager(typeManager, xmlMap.readDtoMapping());
     this.beanDescriptorManager = new BeanDescriptorManager(this);
     Map<String, String> asOfTableMapping = beanDescriptorManager.deploy(xmlMap.xmlDeployment());
-    Map<String, String> draftTableMap = beanDescriptorManager.getDraftTableMap();
+    Map<String, String> draftTableMap = beanDescriptorManager.draftTableMap();
     beanDescriptorManager.scheduleBackgroundTrim();
     this.dataTimeZone = initDataTimeZone();
     this.binder = getBinder(typeManager, databasePlatform, dataTimeZone);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/OrmQueryRequest.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/OrmQueryRequest.java
index 0fb83a18f..64f63a0fc 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/OrmQueryRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/OrmQueryRequest.java
@@ -60,42 +60,25 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   private static final Logger log = LoggerFactory.getLogger(OrmQueryRequest.class);
 
   private final BeanDescriptor<T> beanDescriptor;
-
   private final OrmQueryEngine queryEngine;
-
   private final SpiQuery<T> query;
-
   private final BeanFindController finder;
-
   private final Boolean readOnly;
-
   private LoadContext loadContext;
-
   private PersistenceContext persistenceContext;
-
   private JsonReadOptions jsonRead;
-
   private HashQuery cacheKey;
-
   private CQueryPlanKey queryPlanKey;
-
   private SpiQuerySecondary secondaryQueries;
-
   private List<T> cacheBeans;
-
   private BeanPropertyAssocMany<?> manyProperty;
-
   private boolean inlineCountDistinct;
-
   private Set<String> dependentTables;
 
-  /**
-   * Create the InternalQueryRequest.
-   */
   public OrmQueryRequest(SpiEbeanServer server, OrmQueryEngine queryEngine, SpiQuery<T> query, SpiTransaction t) {
     super(server, t);
     this.beanDescriptor = query.getBeanDescriptor();
-    this.finder = beanDescriptor.getBeanFinder();
+    this.finder = beanDescriptor.beanFinder();
     this.queryEngine = queryEngine;
     this.query = query;
     this.readOnly = query.isReadOnly();
@@ -145,8 +128,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Return the database platform like clause.
    */
   @Override
-  public String getDBLikeClause(boolean rawLikeExpression) {
-    return ebeanServer.getDatabasePlatform().getLikeClause(rawLikeExpression);
+  public String dbLikeClause(boolean rawLikeExpression) {
+    return server.databasePlatform().getLikeClause(rawLikeExpression);
   }
 
   /**
@@ -154,7 +137,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    */
   @Override
   public String escapeLikeString(String value) {
-    return ebeanServer.getDatabasePlatform().escapeLikeString(value);
+    return server.databasePlatform().escapeLikeString(value);
   }
 
   @Override
@@ -171,9 +154,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * <p>
    * If -1 is returned then NO secondary queries are registered and simple
    * iteration is fine.
-   * </p>
    */
-  public int getSecondaryQueriesMinBatchSize() {
+  public int secondaryQueriesMinBatchSize() {
     return loadContext.getSecondaryQueriesMinBatchSize();
   }
 
@@ -188,14 +170,14 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Return the BeanDescriptor for the associated bean.
    */
   @Override
-  public BeanDescriptor<T> getBeanDescriptor() {
+  public BeanDescriptor<T> descriptor() {
     return beanDescriptor;
   }
 
   /**
    * Return the graph context for this query.
    */
-  public LoadContext getGraphContext() {
+  public LoadContext loadContext() {
     return loadContext;
   }
 
@@ -208,7 +190,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Run BeanQueryAdapter preQuery() if needed.
    */
   private void adapterPreQuery() {
-    BeanQueryAdapter queryAdapter = beanDescriptor.getQueryAdapter();
+    BeanQueryAdapter queryAdapter = beanDescriptor.queryAdapter();
     if (queryAdapter != null) {
       queryAdapter.preQuery(this);
     }
@@ -244,7 +226,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return the PersistenceContext used for this request.
    */
-  public PersistenceContext getPersistenceContext() {
+  public PersistenceContext persistenceContext() {
     return persistenceContext;
   }
 
@@ -271,15 +253,15 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
     if (transaction == null) {
       if (query.getType().isUpdate()) {
         // bulk update or delete query
-        transaction = ebeanServer.beginServerTransaction();
+        transaction = server.beginServerTransaction();
       } else {
         // create an implicit transaction to execute this query
         // potentially using read-only DataSource with autoCommit
-        transaction = ebeanServer.createReadOnlyTransaction(query.getTenantId());
+        transaction = server.createReadOnlyTransaction(query.getTenantId());
       }
       createdTransaction = true;
     }
-    persistenceContext = getPersistenceContext(query, transaction);
+    persistenceContext = persistenceContext(query, transaction);
     loadContext = new DLoadContext(this, secondaryQueries);
   }
 
@@ -305,7 +287,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    */
   @Override
   public JsonReadOptions createJsonReadOptions() {
-    persistenceContext = getPersistenceContext(query, transaction);
+    persistenceContext = persistenceContext(query, transaction);
     if (query.getPersistenceContext() == null) {
       query.setPersistenceContext(persistenceContext);
     }
@@ -336,14 +318,14 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Get the TransactionContext either explicitly set on the query or
    * transaction scoped.
    */
-  private PersistenceContext getPersistenceContext(SpiQuery<?> query, SpiTransaction t) {
+  private PersistenceContext persistenceContext(SpiQuery<?> query, SpiTransaction t) {
     // check if there is already a persistence context set which is the case
     // when lazy loading or query joins are executed
     PersistenceContext ctx = query.getPersistenceContext();
     if (ctx != null) return ctx;
 
     // determine the scope (from the query and then server)
-    PersistenceContextScope scope = ebeanServer.getPersistenceContextScope(query);
+    PersistenceContextScope scope = server.persistenceContextScope(query);
     if (scope == PersistenceContextScope.QUERY || t == null) {
       return new DefaultPersistenceContext();
     }
@@ -365,7 +347,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
       transaction.commit();
       if (query.getType().isUpdate()) {
         // for implicit update/delete queries clear the thread local
-        ebeanServer.clearServerTransaction();
+        server.clearServerTransaction();
       }
     }
   }
@@ -486,9 +468,9 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   public <K> Map<K, T> findMap() {
     String mapKey = query.getMapKey();
     if (mapKey == null) {
-      BeanProperty idProp = beanDescriptor.getIdProperty();
+      BeanProperty idProp = beanDescriptor.idProperty();
       if (idProp != null) {
-        query.setMapKey(idProp.getName());
+        query.setMapKey(idProp.name());
       } else {
         throw new PersistenceException("No mapKey specified for query");
       }
@@ -504,12 +486,12 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return a bean specific finder if one has been set.
    */
-  public BeanFindController getBeanFinder() {
+  public BeanFindController finder() {
     return finder;
   }
 
   @Override
-  public SpiQuery<T> getQuery() {
+  public SpiQuery<T> query() {
     return query;
   }
 
@@ -517,14 +499,14 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Determine and return the ToMany property that is included in the query.
    */
   public BeanPropertyAssocMany<?> determineMany() {
-    manyProperty = beanDescriptor.getManyProperty(query);
+    manyProperty = beanDescriptor.manyProperty(query);
     return manyProperty;
   }
 
   /**
    * Return the many property that is fetched in the query or null if there is not one.
    */
-  public BeanPropertyAssocMany<?> getManyProperty() {
+  public BeanPropertyAssocMany<?> manyProperty() {
     return manyProperty;
   }
 
@@ -532,8 +514,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Return a queryPlan for the current query if one exists. Returns null if no
    * query plan for this query exists.
    */
-  public CQueryPlan getQueryPlan() {
-    return beanDescriptor.getQueryPlan(queryPlanKey);
+  public CQueryPlan queryPlan() {
+    return beanDescriptor.queryPlan(queryPlanKey);
   }
 
   /**
@@ -542,9 +524,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * This identifies the query plan for a given bean type. It effectively
    * matches a SQL statement with ? bind variables. A query plan can be reused
    * with just the bind variables changing.
-   * </p>
    */
-  public CQueryPlanKey getQueryPlanKey() {
+  public CQueryPlanKey queryPlanKey() {
     return queryPlanKey;
   }
 
@@ -552,7 +533,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Put the QueryPlan into the cache.
    */
   public void putQueryPlan(CQueryPlan queryPlan) {
-    beanDescriptor.putQueryPlan(queryPlanKey, queryPlan);
+    beanDescriptor.queryPlan(queryPlanKey, queryPlan);
   }
 
   @Override
@@ -608,7 +589,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   }
 
   @Override
-  public List<T> getBeanCacheHits() {
+  public List<T> beanCacheHits() {
     OrderBy<T> orderBy = query.getOrderBy();
     if (orderBy != null) {
       beanDescriptor.sort(cacheBeans, orderBy.toStringFormat());
@@ -617,7 +598,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   }
 
   @Override
-  public <K> Map<K, T> getBeanCacheHitsAsMap() {
+  public <K> Map<K, T> beanCacheHitsAsMap() {
     OrderBy<T> orderBy = query.getOrderBy();
     if (orderBy != null) {
       beanDescriptor.sort(cacheBeans, orderBy.toStringFormat());
@@ -636,7 +617,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   }
 
   private ElPropertyValue mapProperty() {
-    ElPropertyValue property = beanDescriptor.getElGetValue(query.getMapKey());
+    ElPropertyValue property = beanDescriptor.elGetValue(query.getMapKey());
     if (property == null) {
       throw new IllegalStateException("Unknown map key property "+query.getMapKey());
     }
@@ -665,7 +646,6 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
     if (!beanDescriptor.isNaturalKeyCaching()) {
       return false;
     }
-
     NaturalKeyQueryData<T> data = query.naturalKey();
     if (data != null) {
       NaturalKeySet naturalKeySet = data.buildKeys();
@@ -688,30 +668,27 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   public Object getFromQueryCache() {
     if (query.getUseQueryCache() == CacheMode.OFF
       || (transaction != null && transaction.isSkipCache())
-      || ebeanServer.isDisableL2Cache()) {
+      || server.isDisableL2Cache()) {
       return null;
     } else {
       cacheKey = query.queryHash();
     }
-
     if (!query.getUseQueryCache().isGet()) {
       return null;
     }
 
     Object cached = beanDescriptor.queryCacheGet(cacheKey);
-
     if (cached != null && isAuditReads() && readAuditQueryType()) {
       if (cached instanceof BeanCollection) {
         // raw sql can't use L2 cache so normal queries only in here
         Collection<T> actualDetails = ((BeanCollection<T>)cached).getActualDetails();
         List<Object> ids = new ArrayList<>(actualDetails.size());
         for (T bean : actualDetails) {
-          ids.add(beanDescriptor.getIdForJson(bean));
+          ids.add(beanDescriptor.idForJson(bean));
         }
         beanDescriptor.readAuditMany(queryPlanKey.getPartialKey(), "l2-query-cache", ids);
       }
     }
-
     if (Boolean.FALSE.equals(query.isReadOnly())) {
       // return shallow copies if readonly is explicitly set to false
       if (cached instanceof BeanCollection) {
@@ -750,7 +727,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   }
 
   /**
-   * Set an Query object that owns the PreparedStatement that can be cancelled.
+   * Set a Query object that owns the PreparedStatement that can be cancelled.
    */
   public void setCancelableQuery(CancelableQuery cancelableQuery) {
     query.setCancelableQuery(cancelableQuery);
@@ -766,16 +743,15 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return the batch size for lazy loading on this bean query request.
    */
-  public int getLazyLoadBatchSize() {
+  public int lazyLoadBatchSize() {
     int batchSize = query.getLazyLoadBatchSize();
-    return (batchSize > 0) ? batchSize : ebeanServer.getLazyLoadBatchSize();
+    return (batchSize > 0) ? batchSize : server.lazyLoadBatchSize();
   }
 
   /**
    * Return true if read auditing is on for this query request.
    * <p>
    * This means that read audit is on for this bean type and that query has not explicitly disabled it.
-   * </p>
    */
   public boolean isAuditReads() {
     return beanDescriptor.isReadAuditing() && !query.isDisableReadAudit();
@@ -784,8 +760,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return the base table alias for this query.
    */
-  public String getBaseTableAlias() {
-    return query.getAlias(beanDescriptor.getBaseTableAlias());
+  public String baseTableAlias() {
+    return query.getAlias(beanDescriptor.baseTableAlias());
   }
 
   /**
@@ -798,7 +774,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return the tenantId associated with this request.
    */
-  public Object getTenantId() {
+  public Object tenantId() {
     return (transaction == null) ? null : transaction.getTenantId();
   }
 
@@ -806,7 +782,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Check for slow query event.
    */
   public void slowQueryCheck(long executionTimeMicros, int rowCount) {
-    ebeanServer.slowQueryCheck(executionTimeMicros, rowCount, query);
+    server.slowQueryCheck(executionTimeMicros, rowCount, query);
   }
 
   public void setInlineCountDistinct() {
@@ -830,6 +806,6 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Return true if no MaxRows or use LIMIT in SQL update.
    */
   public boolean isInlineSqlUpdateLimit() {
-    return query.getMaxRows() < 1 || ebeanServer.getDatabasePlatform().isInlineSqlUpdateLimit();
+    return query.getMaxRows() < 1 || server.databasePlatform().isInlineSqlUpdateLimit();
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistDeferredRelationship.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistDeferredRelationship.java
index 41bbb20ef..279bf6329 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistDeferredRelationship.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistDeferredRelationship.java
@@ -35,13 +35,13 @@ public final class PersistDeferredRelationship {
    */
   public void execute(SpiTransaction transaction) {
 
-    String sql = beanDescriptor.getUpdateImportedIdSql(importedId);
+    String sql = beanDescriptor.updateImportedIdSql(importedId);
     SqlUpdate sqlUpdate = ebeanServer.sqlUpdate(sql);
 
     // bind the set clause for the importedId
     int pos = importedId.bind(1, sqlUpdate, assocBean);
     // bind the where clause for the bean
-    Object[] idValues = beanDescriptor.getIdBinder().getIdValues(bean);
+    Object[] idValues = beanDescriptor.idBinder().getIdValues(bean);
     for (int j = 0; j < idValues.length; j++) {
       sqlUpdate.setParameter(pos + j, idValues[j]);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequest.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequest.java
index af6ed1aeb..1eab09911 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequest.java
@@ -31,17 +31,10 @@ public abstract class PersistRequest extends BeanRequest implements BatchPostExe
     }
   }
 
-  boolean persistCascade;
-
-  /**
-   * One of INSERT, UPDATE, DELETE, UPDATESQL or CALLABLESQL.
-   */
   protected Type type;
-
+  boolean persistCascade;
   final PersistExecute persistExecute;
-
   protected String label;
-
   protected long startNanos;
 
   PersistRequest(SpiEbeanServer server, SpiTransaction t, PersistExecute persistExecute) {
@@ -95,12 +88,12 @@ public abstract class PersistRequest extends BeanRequest implements BatchPostExe
   }
 
   @Override
-  public boolean isLogSql() {
+  public boolean logSql() {
     return transaction.isLogSql();
   }
 
   @Override
-  public boolean isLogSummary() {
+  public boolean logSummary() {
     return transaction.isLogSummary();
   }
 
@@ -149,10 +142,9 @@ public abstract class PersistRequest extends BeanRequest implements BatchPostExe
   }
 
   /**
-   * Return the type of this request. One of INSERT, UPDATE, DELETE, UPDATESQL
-   * or CALLABLESQL.
+   * Return the type of this request. One of INSERT, UPDATE, DELETE, UPDATESQL or CALLABLESQL.
    */
-  public Type getType() {
+  public Type type() {
     return type;
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestBean.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestBean.java
index 07aac16bb..fd4f8e555 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestBean.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestBean.java
@@ -50,142 +50,94 @@ import java.util.Set;
 public final class PersistRequestBean<T> extends PersistRequest implements BeanPersistRequest<T>, DocStoreUpdate, PreGetterCallback, SpiProfileTransactionEvent {
 
   private final BeanManager<T> beanManager;
-
   private final BeanDescriptor<T> beanDescriptor;
-
   private final BeanPersistListener beanPersistListener;
-
-  /**
-   * For per post insert update delete control.
-   */
   private final BeanPersistController controller;
-
-  /**
-   * The bean being persisted.
-   */
   private final T bean;
-
   private final EntityBean entityBean;
-
-  /**
-   * The associated intercept.
-   */
   private final EntityBeanIntercept intercept;
-
   /**
    * The parent bean for unidirectional save.
    */
   private final Object parentBean;
-
   private final boolean dirty;
-
   private final boolean publish;
-
   private int flags;
-
   private boolean saveRecurse;
-
   private DocStoreMode docStoreMode;
-
   private final ConcurrencyMode concurrencyMode;
-
   /**
    * The unique id used for logging summary.
    */
   private Object idValue;
-
   /**
    * Hash value used to handle cascade delete both ways in a relationship.
    */
   private Integer beanHash;
-
-  /**
-   * Flag set if this is a stateless update.
-   */
   private boolean statelessUpdate;
-
   private boolean notifyCache;
-
   /**
    * Flag used to detect when only many properties where updated via a cascade. Used to ensure
    * appropriate caches are updated in that case.
    */
   private boolean updatedManysOnly;
-
   /**
    * Element collection change as part of bean cache.
    */
   private Map<String, Object> collectionChanges;
-
   /**
    * Set true when the request includes cascade save to a many.
    */
   private boolean updatedMany;
-
   /**
    * Many properties that were cascade saved (and hence might need caches updated later).
    */
   private List<BeanPropertyAssocMany<?>> updatedManys;
-
   /**
    * Need to get and store the updated properties because the persist listener is notified
    * later on a different thread and the bean has been reset at that point.
    */
   private Set<String> updatedProperties;
-
   /**
    * Flags indicating the dirty properties on the bean.
    */
   private boolean[] dirtyProperties;
-
   /**
    * Imported OneToOne orphan that needs to be deleted.
    */
   private EntityBean orphanBean;
-
   /**
    * Flag set when request is added to JDBC batch.
    */
   private boolean batched;
-
   /**
    * Flag set when batchOnCascade to avoid using batch on the top bean.
    */
   private boolean skipBatchForTopLevel;
-
   /**
    * Flag set when batch mode is turned on for a persist cascade.
    */
   private boolean batchOnCascadeSet;
-
   /**
    * Set for updates to determine if all loaded properties are included in the update.
    */
   private boolean requestUpdateAllLoadedProps;
-
   private long version;
-
   private long now;
-
   private long profileOffset;
-
   /**
    * Flag set when request is added to JDBC batch registered as a "getter callback" to automatically flush batch.
    */
   private boolean getterCallback;
-
   private boolean pendingPostUpdateNotify;
-
   /**
    * Set to true when post execute has occurred (so includes batch flush).
    */
   private boolean postExecute;
-
   /**
    * Set to true after many properties have been persisted (so includes element collections).
    */
   private boolean complete;
-
   /**
    * Many to many intersection table changes that are held for later batch processing.
    */
@@ -198,10 +150,10 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     this.intercept = entityBean._ebean_getIntercept();
     this.beanManager = mgr;
     this.beanDescriptor = mgr.getBeanDescriptor();
-    this.beanPersistListener = beanDescriptor.getPersistListener();
+    this.beanPersistListener = beanDescriptor.persistListener();
     this.bean = bean;
     this.parentBean = parentBean;
-    this.controller = beanDescriptor.getPersistController();
+    this.controller = beanDescriptor.persistController();
     this.type = type;
     this.docStoreMode = calcDocStoreMode(transaction, type);
     this.flags = flags;
@@ -217,7 +169,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       // Mark Mutable scalar properties (like Hstore) as dirty where necessary
       beanDescriptor.checkMutableProperties(intercept);
     }
-    this.concurrencyMode = beanDescriptor.getConcurrencyMode(intercept);
+    this.concurrencyMode = beanDescriptor.concurrencyMode(intercept);
     this.publish = Flags.isPublish(flags);
     if (isMarkDraftDirty(publish)) {
       beanDescriptor.setDraftDirty(entityBean, true);
@@ -247,7 +199,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    */
   @Override
   public void profile(long offset, int flushCount) {
-    profileBase(type.profileEventId, offset, beanDescriptor.getName(), flushCount);
+    profileBase(type.profileEventId, offset, beanDescriptor.name(), flushCount);
   }
 
   /**
@@ -258,7 +210,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    */
   private DocStoreMode calcDocStoreMode(SpiTransaction txn, Type type) {
     DocStoreMode txnMode = (txn == null) ? null : txn.getDocStoreMode();
-    return beanDescriptor.getDocStoreMode(type, txnMode);
+    return beanDescriptor.docStoreMode(type, txnMode);
   }
 
   /**
@@ -320,21 +272,21 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
   private void onUpdateGeneratedProperties() {
     for (BeanProperty prop : beanDescriptor.propertiesGenUpdate()) {
-      GeneratedProperty generatedProperty = prop.getGeneratedProperty();
+      GeneratedProperty generatedProperty = prop.generatedProperty();
       if (prop.isVersion()) {
         if (isLoadedProperty(prop)) {
           // @Version property must be loaded to be involved
           Object value = generatedProperty.getUpdateValue(prop, entityBean, now());
           Object oldVal = prop.getValue(entityBean);
           setVersionValue(value);
-          intercept.setOldValue(prop.getPropertyIndex(), oldVal);
+          intercept.setOldValue(prop.propertyIndex(), oldVal);
         }
       } else {
         // @WhenModified set without invoking interception
         Object oldVal = prop.getValue(entityBean);
         Object value = generatedProperty.getUpdateValue(prop, entityBean, now());
         prop.setValueChanged(entityBean, value);
-        intercept.setOldValue(prop.getPropertyIndex(), oldVal);
+        intercept.setOldValue(prop.propertyIndex(), oldVal);
       }
     }
   }
@@ -348,7 +300,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
   private void onInsertGeneratedProperties() {
     for (BeanProperty prop : beanDescriptor.propertiesGenInsert()) {
-      Object value = prop.getGeneratedProperty().getInsertValue(prop, entityBean, now());
+      Object value = prop.generatedProperty().getInsertValue(prop, entityBean, now());
       prop.setValueChanged(entityBean, value);
     }
   }
@@ -431,12 +383,12 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   }
 
   @Override
-  public Set<String> getLoadedProperties() {
+  public Set<String> loadedProperties() {
     return intercept.getLoadedPropertyNames();
   }
 
   @Override
-  public Set<String> getUpdatedProperties() {
+  public Set<String> updatedProperties() {
     return intercept.getDirtyPropertyNames();
   }
 
@@ -444,7 +396,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Return the dirty properties on this request.
    */
   @Override
-  public boolean[] getDirtyProperties() {
+  public boolean[] dirtyProperties() {
     return dirtyProperties;
   }
 
@@ -469,7 +421,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   }
 
   @Override
-  public Map<String, ValuePair> getUpdatedValues() {
+  public Map<String, ValuePair> updatedValues() {
     return intercept.getDirtyValues();
   }
 
@@ -550,10 +502,10 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       case INSERT:
       case UPDATE:
       case DELETE_SOFT:
-        docStoreUpdates.queueIndex(beanDescriptor.getDocStoreQueueId(), idValue);
+        docStoreUpdates.queueIndex(beanDescriptor.docStoreQueueId(), idValue);
         break;
       case DELETE:
-        docStoreUpdates.queueDelete(beanDescriptor.getDocStoreQueueId(), idValue);
+        docStoreUpdates.queueDelete(beanDescriptor.docStoreQueueId(), idValue);
         break;
       default:
         throw new IllegalStateException("Invalid type " + type);
@@ -589,8 +541,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   }
 
   /**
-   * Return true if this bean has been already been persisted (inserted or updated) in this
-   * transaction.
+   * Return true if this bean has been already been persisted (inserted or updated) in this transaction.
    */
   public boolean isRegisteredBean() {
     return transaction.isRegisteredBean(bean);
@@ -607,7 +558,6 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * The hash used to register the bean with the transaction.
    * <p>
    * Takes into account the class type and id value.
-   * </p>
    */
   private Integer getBeanHash() {
     if (beanHash == null) {
@@ -638,7 +588,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the BeanDescriptor for the associated bean.
    */
-  public BeanDescriptor<T> getBeanDescriptor() {
+  public BeanDescriptor<T> descriptor() {
     return beanDescriptor;
   }
 
@@ -663,7 +613,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the concurrency mode used for this persist.
    */
-  public ConcurrencyMode getConcurrencyMode() {
+  public ConcurrencyMode concurrencyMode() {
     return concurrencyMode;
   }
 
@@ -674,26 +624,26 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Used to determine common persist requests for queueing and statement batching.
    * </p>
    */
-  public String getFullName() {
-    return beanDescriptor.getFullName();
+  public String fullName() {
+    return beanDescriptor.fullName();
   }
 
   /**
    * Return the bean associated with this request.
    */
   @Override
-  public T getBean() {
+  public T bean() {
     return bean;
   }
 
-  public EntityBean getEntityBean() {
+  public EntityBean entityBean() {
     return entityBean;
   }
 
   /**
    * Return the Id value for the bean.
    */
-  public Object getBeanId() {
+  public Object beanId() {
     return beanDescriptor.getId(entityBean);
   }
 
@@ -701,7 +651,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Create and return a new reference bean matching this beans Id value.
    */
   public T createReference() {
-    return beanDescriptor.createRef(getBeanId(), null);
+    return beanDescriptor.createRef(beanId(), null);
   }
 
   /**
@@ -746,14 +696,14 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the parent bean for cascading save with unidirectional relationship.
    */
-  public Object getParentBean() {
+  public Object parentBean() {
     return parentBean;
   }
 
   /**
    * Return the intercept if there is one.
    */
-  public EntityBeanIntercept getEntityBeanIntercept() {
+  public EntityBeanIntercept intercept() {
     return intercept;
   }
 
@@ -761,21 +711,21 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Return true if this property is loaded (full bean or included in partial bean).
    */
   public boolean isLoadedProperty(BeanProperty prop) {
-    return intercept.isLoadedProperty(prop.getPropertyIndex());
+    return intercept.isLoadedProperty(prop.propertyIndex());
   }
 
   /**
    * Return true if the property is dirty.
    */
   public boolean isDirtyProperty(BeanProperty prop) {
-    return intercept.isDirtyProperty(prop.getPropertyIndex());
+    return intercept.isDirtyProperty(prop.propertyIndex());
   }
 
   /**
    * Return the original / old value for the given property.
    */
   public Object getOrigValue(BeanProperty prop) {
-    return intercept.getOrigValue(prop.getPropertyIndex());
+    return intercept.getOrigValue(prop.propertyIndex());
   }
 
   @Override
@@ -790,7 +740,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       case UPDATE:
         if (beanPersistListener != null) {
           // store the updated properties for sending later
-          updatedProperties = getUpdatedProperties();
+          updatedProperties = updatedProperties();
         }
         executeUpdate();
         return -1;
@@ -809,7 +759,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Soft delete is executed as update so we want to set deleted=true property.
    */
   private void prepareForSoftDelete() {
-    beanDescriptor.setSoftDeleteValue(entityBean);
+    beanDescriptor.softDeleteValue(entityBean);
   }
 
   @Override
@@ -861,7 +811,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Check for optimistic concurrency exception.
    */
   @Override
-  public final void checkRowCount(int rowCount) {
+  public void checkRowCount(int rowCount) {
     if (rowCount != 1 && rowCount != Statement.SUCCESS_NO_INFO) {
       if (ConcurrencyMode.VERSION == concurrencyMode) {
         onFailedUpdateUndoGeneratedProperties();
@@ -913,7 +863,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   }
 
   private void changeLog() {
-    BeanChange changeLogBean = beanDescriptor.getChangeLogBean(this);
+    BeanChange changeLogBean = beanDescriptor.changeLogBean(this);
     if (changeLogBean != null) {
       transaction.addBeanChange(changeLogBean);
     }
@@ -945,8 +895,8 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     }
     addPostCommitListeners();
     notifyCacheOnPostExecute();
-    if (isLogSummary()) {
-      logSummary();
+    if (logSummary()) {
+      logSummaryMessage();
     }
   }
 
@@ -993,9 +943,9 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     }
   }
 
-  private void logSummary() {
+  private void logSummaryMessage() {
     String draft = (beanDescriptor.isDraftable() && !publish) ? " draft[true]" : "";
-    String name = beanDescriptor.getName();
+    String name = beanDescriptor.name();
     switch (type) {
       case INSERT:
         transaction.logSummary("Inserted [" + name + "] [" + idValue + "]" + draft);
@@ -1029,9 +979,9 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    */
   public boolean isAddToUpdate(BeanProperty prop) {
     if (requestUpdateAllLoadedProps) {
-      return intercept.isLoadedProperty(prop.getPropertyIndex());
+      return intercept.isLoadedProperty(prop.propertyIndex());
     } else {
-      return intercept.isDirtyProperty(prop.getPropertyIndex());
+      return intercept.isDirtyProperty(prop.propertyIndex());
     }
   }
 
@@ -1039,7 +989,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Register the derived relationships to get executed later (on JDBC batch flush or commit).
    */
   public void deferredRelationship(EntityBean assocBean, ImportedId importedId, EntityBean bean) {
-    transaction.registerDeferred(new PersistDeferredRelationship(ebeanServer, beanDescriptor, assocBean, importedId, bean));
+    transaction.registerDeferred(new PersistDeferredRelationship(server, beanDescriptor, assocBean, importedId, bean));
   }
 
   private void postInsert() {
@@ -1082,7 +1032,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the list of updated many properties for L2 cache update (can be null).
    */
-  public List<BeanPropertyAssocMany<?>> getUpdatedManyForL2Cache() {
+  public List<BeanPropertyAssocMany<?>> updatedManyForL2Cache() {
     return updatedManys;
   }
 
@@ -1159,9 +1109,9 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       }
       case QUEUE: {
         if (type == Type.DELETE) {
-          docStoreUpdates.queueDelete(beanDescriptor.getDocStoreQueueId(), idValue);
+          docStoreUpdates.queueDelete(beanDescriptor.docStoreQueueId(), idValue);
         } else {
-          docStoreUpdates.queueIndex(beanDescriptor.getDocStoreQueueId(), idValue);
+          docStoreUpdates.queueIndex(beanDescriptor.docStoreQueueId(), idValue);
         }
       }
       break;
@@ -1183,7 +1133,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       requestUpdateAllLoadedProps = txnUpdateAll;
     } else {
       // if using batch use the server default setting
-      requestUpdateAllLoadedProps = isBatchThisRequest() && ebeanServer.isUpdateAllPropertiesInBatch();
+      requestUpdateAllLoadedProps = isBatchThisRequest() && server.isUpdateAllPropertiesInBatch();
     }
     return requestUpdateAllLoadedProps;
   }
@@ -1191,7 +1141,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the flags set on this persist request.
    */
-  public int getFlags() {
+  public int flags() {
     return flags;
   }
 
@@ -1205,16 +1155,16 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the key for an update persist request.
    */
-  public String getUpdatePlanHash() {
+  public String updatePlanHash() {
     StringBuilder key;
     if (determineUpdateAllLoadedProperties()) {
       key = intercept.getLoadedPropertyKey();
     } else {
       key = intercept.getDirtyPropertyKey();
     }
-    BeanProperty versionProperty = beanDescriptor.getVersionProperty();
+    BeanProperty versionProperty = beanDescriptor.versionProperty();
     if (versionProperty != null) {
-      if (intercept.isLoadedProperty(versionProperty.getPropertyIndex())) {
+      if (intercept.isLoadedProperty(versionProperty.propertyIndex())) {
         key.append('v');
       }
     }
@@ -1227,8 +1177,8 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the table to update depending if the request is a 'publish' one or normal.
    */
-  public String getUpdateTable() {
-    return publish ? beanDescriptor.getBaseTable() : beanDescriptor.getDraftTable();
+  public String updateTable() {
+    return publish ? beanDescriptor.baseTable() : beanDescriptor.draftTable();
   }
 
   /**
@@ -1248,7 +1198,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the version in long form (if set).
    */
-  public long getVersion() {
+  public long version() {
     return version;
   }
 
@@ -1321,7 +1271,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    */
   public long now() {
     if (now == 0) {
-      now = ebeanServer.clockNow();
+      now = server.clockNow();
     }
     return now;
   }
@@ -1338,7 +1288,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    */
   @Override
   public void profile() {
-    profileBase(type.profileEventId, profileOffset, beanDescriptor.getName(), 1);
+    profileBase(type.profileEventId, profileOffset, beanDescriptor.name(), 1);
   }
 
   /**
@@ -1391,15 +1341,15 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
       String key = beanDescriptor.cacheKey(idValue);
       Map<String, Object> changes = new LinkedHashMap<>();
-      EntityBean bean = getEntityBean();
-      boolean[] dirtyProperties = getDirtyProperties();
+      EntityBean bean = entityBean();
+      boolean[] dirtyProperties = dirtyProperties();
       if (dirtyProperties != null) {
         for (int i = 0; i < dirtyProperties.length; i++) {
           if (dirtyProperties[i]) {
             BeanProperty property = beanDescriptor.propertyByIndex(i);
             if (property.isCacheDataInclude()) {
               Object val = property.getCacheDataValue(bean);
-              changes.put(property.getName(), val);
+              changes.put(property.name(), val);
               if (property.isNaturalKey()) {
                 updateNaturalKey = true;
                 String valStr = (val == null) ? null : val.toString();
@@ -1413,7 +1363,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
         // add element collection update
         changes.putAll(collectionChanges);
       }
-      changeSet.addBeanUpdate(beanDescriptor, key, changes, updateNaturalKey, getVersion());
+      changeSet.addBeanUpdate(beanDescriptor, key, changes, updateNaturalKey, version());
     }
   }
 
@@ -1427,7 +1377,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     }
   }
 
-  public EntityBean getImportedOrphanForRemoval() {
+  public EntityBean importedOrphanForRemoval() {
     return orphanBean;
   }
 
@@ -1435,7 +1385,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Return the SQL used to fetch the last inserted id value.
    */
   public String getSelectLastInsertedId() {
-    return beanDescriptor.getSelectLastInsertedId(publish);
+    return beanDescriptor.selectLastInsertedId(publish);
   }
 
   /**
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestCallableSql.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestCallableSql.java
index 806691f5f..1edabf5bd 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestCallableSql.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestCallableSql.java
@@ -19,20 +19,15 @@ import java.util.List;
 public final class PersistRequestCallableSql extends PersistRequest {
 
   private final SpiCallableSql callableSql;
-
   private int rowCount;
-
   private String bindLog;
-
   private CallableStatement cstmt;
-
   private BindParams bindParam;
 
   /**
    * Create.
    */
   public PersistRequestCallableSql(SpiEbeanServer server, CallableSql cs, SpiTransaction t, PersistExecute persistExecute) {
-
     super(server, t, persistExecute, cs.getLabel());
     this.type = PersistRequest.Type.CALLABLESQL;
     this.callableSql = (SpiCallableSql) cs;
@@ -56,7 +51,7 @@ public final class PersistRequestCallableSql extends PersistRequest {
   /**
    * Return the CallableSql.
    */
-  public SpiCallableSql getCallableSql() {
+  public SpiCallableSql callableSql() {
     return callableSql;
   }
 
@@ -97,13 +92,11 @@ public final class PersistRequestCallableSql extends PersistRequest {
 
     // register table modifications with the transaction event
     TransactionEventTable tableEvents = callableSql.getTransactionEventTable();
-
     if (tableEvents != null && !tableEvents.isEmpty()) {
       transaction.getEvent().add(tableEvents);
     } else {
       transaction.markNotQueryOnly();
     }
-
   }
 
   /**
@@ -120,7 +113,6 @@ public final class PersistRequestCallableSql extends PersistRequest {
    * Execute the statement in normal non batch mode.
    */
   public int executeUpdate() throws SQLException {
-
     // check to see if the execution has been overridden
     // only works in non-batch mode
     if (callableSql.executeOverride(cstmt)) {
@@ -129,20 +121,15 @@ public final class PersistRequestCallableSql extends PersistRequest {
       // rowCount = callableSql.getRowCount();
       // return rowCount;
     }
-
     rowCount = cstmt.executeUpdate();
-
     // only read in non-batch mode
     readOutParams();
-
     return rowCount;
   }
 
   private void readOutParams() throws SQLException {
-
     List<Param> list = bindParam.positionedParameters();
     int pos = 0;
-
     for (Param param : list) {
       pos++;
       if (param.isOutParam()) {
@@ -151,5 +138,4 @@ public final class PersistRequestCallableSql extends PersistRequest {
       }
     }
   }
-
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestOrmUpdate.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestOrmUpdate.java
index 807feadd8..08de8e27d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestOrmUpdate.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestOrmUpdate.java
@@ -14,19 +14,11 @@ import io.ebeaninternal.server.persist.PersistExecute;
 public final class PersistRequestOrmUpdate extends PersistRequest {
 
   private final BeanDescriptor<?> beanDescriptor;
-
   private final SpiUpdate<?> ormUpdate;
-
   private int rowCount;
-
   private String bindLog;
 
-  /**
-   * Create.
-   */
-  public PersistRequestOrmUpdate(SpiEbeanServer server, BeanManager<?> mgr, SpiUpdate<?> ormUpdate,
-                                 SpiTransaction t, PersistExecute persistExecute) {
-
+  public PersistRequestOrmUpdate(SpiEbeanServer server, BeanManager<?> mgr, SpiUpdate<?> ormUpdate, SpiTransaction t, PersistExecute persistExecute) {
     super(server, t, persistExecute, ormUpdate.getLabel());
     this.beanDescriptor = mgr.getBeanDescriptor();
     this.ormUpdate = ormUpdate;
@@ -34,10 +26,10 @@ public final class PersistRequestOrmUpdate extends PersistRequest {
 
   @Override
   public void profile(long offset, int flushCount) {
-    profileBase(EVT_ORMUPDATE, offset, beanDescriptor.getName(), flushCount);
+    profileBase(EVT_ORMUPDATE, offset, beanDescriptor.name(), flushCount);
   }
 
-  public BeanDescriptor<?> getBeanDescriptor() {
+  public BeanDescriptor<?> descriptor() {
     return beanDescriptor;
   }
 
@@ -51,11 +43,10 @@ public final class PersistRequestOrmUpdate extends PersistRequest {
     return executeStatement();
   }
 
-
   /**
    * Return the UpdateSql.
    */
-  public SpiUpdate<?> getOrmUpdate() {
+  public SpiUpdate<?> ormUpdate() {
     return ormUpdate;
   }
 
@@ -91,14 +82,11 @@ public final class PersistRequestOrmUpdate extends PersistRequest {
     }
     OrmUpdateType ormUpdateType = ormUpdate.getOrmUpdateType();
     String tableName = ormUpdate.getBaseTable();
-
     if (transaction.isLogSummary()) {
       String m = ormUpdateType + " table[" + tableName + "] rows[" + rowCount + "] bind[" + bindLog + "]";
       transaction.logSummary(m);
     }
-
     if (ormUpdate.isNotifyCache()) {
-
       // add the modification info to the TransactionEvent
       // this is used to invalidate cached objects etc
       switch (ormUpdateType) {
@@ -116,5 +104,4 @@ public final class PersistRequestOrmUpdate extends PersistRequest {
       }
     }
   }
-
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestUpdateSql.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestUpdateSql.java
index f16a9d7cd..63f31434a 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestUpdateSql.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestUpdateSql.java
@@ -18,25 +18,17 @@ public final class PersistRequestUpdateSql extends PersistRequest {
   }
 
   private final SpiSqlUpdate updateSql;
-
   private int rowCount;
-
   private String bindLog;
-
   private SqlType sqlType;
-
   private String tableName;
-
   private boolean addBatch;
-
   private final boolean forceNoBatch;
-
   private boolean batchThisRequest;
   private boolean flushQueue;
 
   public PersistRequestUpdateSql(SpiEbeanServer server, SpiSqlUpdate sqlUpdate,
                                  SpiTransaction t, PersistExecute persistExecute, boolean forceNoBatch) {
-
     super(server, t, persistExecute, sqlUpdate.getLabel());
     this.type = Type.UPDATESQL;
     this.updateSql = sqlUpdate;
@@ -105,7 +97,7 @@ public final class PersistRequestUpdateSql extends PersistRequest {
   /**
    * Return the UpdateSql.
    */
-  public SpiSqlUpdate getUpdateSql() {
+  public SpiSqlUpdate updateSql() {
     return updateSql;
   }
 
@@ -145,6 +137,7 @@ public final class PersistRequestUpdateSql extends PersistRequest {
     this.bindLog = bindLog;
   }
 
+  @Override
   public void startBind(boolean batchThisRequest) {
     this.batchThisRequest = batchThisRequest;
     super.startBind(batchThisRequest);
@@ -170,7 +163,6 @@ public final class PersistRequestUpdateSql extends PersistRequest {
     if (transaction.isLogSql() && !batchThisRequest) {
       transaction.logSql(Str.add(TrimLogSql.trim(updateSql.getGeneratedSql()), "; -- bind(", bindLog, ") rows(", String.valueOf(rowCount), ")"));
     }
-
     if (updateSql.isAutoTableMod()) {
       // add the modification info to the TransactionEvent
       // this is used to invalidate cached objects etc
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/SpiOrmQueryRequest.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/SpiOrmQueryRequest.java
index 41cfff829..3c7139476 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/SpiOrmQueryRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/SpiOrmQueryRequest.java
@@ -22,12 +22,12 @@ public interface SpiOrmQueryRequest<T> extends BeanQueryRequest<T>, DocQueryRequ
    * Return the query.
    */
   @Override
-  SpiQuery<T> getQuery();
+  SpiQuery<T> query();
 
   /**
    * Return the associated BeanDescriptor.
    */
-  BeanDescriptor<T> getBeanDescriptor();
+  BeanDescriptor<T> descriptor();
 
   /**
    * Prepare the query for execution.
@@ -145,12 +145,12 @@ public interface SpiOrmQueryRequest<T> extends BeanQueryRequest<T>, DocQueryRequ
   /**
    * Return the bean cache hits (when all hits / no misses).
    */
-  List<T> getBeanCacheHits();
+  List<T> beanCacheHits();
 
   /**
    * Return the bean cache hits for findMap (when all hits / no misses).
    */
-  <K> Map<K,T> getBeanCacheHitsAsMap();
+  <K> Map<K,T> beanCacheHitsAsMap();
 
   /**
    * Reset Bean cache mode AUTO - require explicit setting for bean cache use with findList().
@@ -160,7 +160,7 @@ public interface SpiOrmQueryRequest<T> extends BeanQueryRequest<T>, DocQueryRequ
   /**
    * Return the Database platform like clause.
    */
-  String getDBLikeClause(boolean rawLikeExpression);
+  String dbLikeClause(boolean rawLikeExpression);
 
   /**
    * Escapes a string to use it as exact match in Like clause.
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefExported.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefExported.java
index cf2f00f28..8b2fbe7bd 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefExported.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefExported.java
@@ -13,7 +13,7 @@ final class AssocOneHelpRefExported extends AssocOneHelp {
   AssocOneHelpRefExported(BeanPropertyAssocOne<?> property) {
     super(property);
     this.softDelete = property.targetDescriptor.isSoftDelete();
-    this.softDeletePredicate = (softDelete) ? property.targetDescriptor.getSoftDeletePredicate("") : null;
+    this.softDeletePredicate = (softDelete) ? property.targetDescriptor.softDeletePredicate("") : null;
   }
 
   /**
@@ -22,7 +22,7 @@ final class AssocOneHelpRefExported extends AssocOneHelp {
   @Override
   void appendSelect(DbSqlContext ctx, boolean subQuery) {
     // set appropriate tableAlias for the exported id columns
-    String relativePrefix = ctx.getRelativePrefix(property.getName());
+    String relativePrefix = ctx.getRelativePrefix(property.name());
     ctx.pushTableAlias(relativePrefix);
     property.targetIdBinder.appendSelect(ctx, subQuery);
     ctx.popTableAlias();
@@ -30,7 +30,7 @@ final class AssocOneHelpRefExported extends AssocOneHelp {
 
   @Override
   void appendFrom(DbSqlContext ctx, SqlJoinType joinType) {
-    String relativePrefix = ctx.getRelativePrefix(property.getName());
+    String relativePrefix = ctx.getRelativePrefix(property.name());
     if (softDelete && !ctx.isIncludeSoftDelete()) {
       property.tableJoin.addJoin(joinType, relativePrefix, ctx, softDeletePredicate);
     } else {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefInherit.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefInherit.java
index 3018b7e19..3a471f666 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefInherit.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefInherit.java
@@ -70,7 +70,7 @@ final class AssocOneHelpRefInherit extends AssocOneHelp {
   void appendSelect(DbSqlContext ctx, boolean subQuery) {
     if (!subQuery) {
       // add discriminator column
-      String relativePrefix = ctx.getRelativePrefix(property.getName());
+      String relativePrefix = ctx.getRelativePrefix(property.name());
       String tableAlias = ctx.getTableAlias(relativePrefix);
       ctx.appendColumn(tableAlias, property.targetInheritInfo.getDiscriminatorColumn());
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BaseCollectionHelp.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BaseCollectionHelp.java
index a803e1754..817f4e1de 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BaseCollectionHelp.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BaseCollectionHelp.java
@@ -17,8 +17,8 @@ abstract class BaseCollectionHelp<T> implements BeanCollectionHelp<T> {
 
   BaseCollectionHelp(BeanPropertyAssocMany<T> many) {
     this.many = many;
-    this.targetDescriptor = many.getTargetDescriptor();
-    this.propertyName = many.getName();
+    this.targetDescriptor = many.targetDescriptor();
+    this.propertyName = many.name();
   }
 
    BaseCollectionHelp() {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanChangeJson.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanChangeJson.java
index a4cb98e94..66b3faa45 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanChangeJson.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanChangeJson.java
@@ -54,10 +54,10 @@ final class BeanChangeJson implements BeanDiffVisitor {
   public void visitPush(int position) {
     stack.push(descriptor);
     BeanPropertyAssocOne<?> embedded = (BeanPropertyAssocOne<?>)descriptor.propertiesIndex[position];
-    descriptor = embedded.getTargetDescriptor();
-    newJson.writeStartObject(embedded.getName());
+    descriptor = embedded.targetDescriptor();
+    newJson.writeStartObject(embedded.name());
     if (oldJson != null) {
-      oldJson.writeStartObject(embedded.getName());
+      oldJson.writeStartObject(embedded.name());
     }
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanCollectionHelpFactory.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanCollectionHelpFactory.java
index c3bda06be..c0ce6c264 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanCollectionHelpFactory.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanCollectionHelpFactory.java
@@ -22,7 +22,7 @@ public final class BeanCollectionHelpFactory {
    */
   public static <T> BeanCollectionHelp<T> create(BeanPropertyAssocMany<T> many) {
     boolean elementCollection = many.isElementCollection();
-    ManyType manyType = many.getManyType();
+    ManyType manyType = many.manyType();
     switch (manyType) {
       case LIST:
         return elementCollection ? new BeanListHelpElement<>(many) : new BeanListHelp<>(many);
@@ -44,8 +44,8 @@ public final class BeanCollectionHelpFactory {
       return SET_HELP;
 
     } else if (manyType == SpiQuery.Type.MAP) {
-      BeanDescriptor<T> target = request.getBeanDescriptor();
-      ElPropertyValue elProperty = target.getElGetValue(request.getQuery().getMapKey());
+      BeanDescriptor<T> target = request.descriptor();
+      ElPropertyValue elProperty = target.elGetValue(request.query().getMapKey());
       return new BeanMapQueryHelp<>(elProperty);
 
     } else {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java
index 6541cade1..0635d5e06 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java
@@ -352,7 +352,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     this.idOnlyReference = isIdOnlyReference(propertiesBaseScalar);
     boolean noRelationships = propertiesOne.length + propertiesMany.length == 0;
     this.cacheSharableBeans = noRelationships && deploy.getCacheOptions().isReadOnly();
-    this.cacheHelp = new BeanDescriptorCacheHelp<>(this, owner.getCacheManager(), deploy.getCacheOptions(), cacheSharableBeans, propertiesOneImported);
+    this.cacheHelp = new BeanDescriptorCacheHelp<>(this, owner.cacheManager(), deploy.getCacheOptions(), cacheSharableBeans, propertiesOneImported);
     this.jsonHelp = initJsonHelp();
     this.draftHelp = new BeanDescriptorDraftHelp<>(this);
     this.docStoreAdapter = owner.createDocStoreBeanAdapter(this, deploy);
@@ -380,8 +380,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
       this.propertiesIndex = new BeanProperty[0];
     } else {
       EntityBeanIntercept ebi = prototypeEntityBean._ebean_getIntercept();
-      this.idPropertyIndex = (idProperty == null) ? -1 : ebi.findProperty(idProperty.getName());
-      this.versionPropertyIndex = (versionProperty == null) ? -1 : ebi.findProperty(versionProperty.getName());
+      this.idPropertyIndex = (idProperty == null) ? -1 : ebi.findProperty(idProperty.name());
+      this.versionPropertyIndex = (versionProperty == null) ? -1 : ebi.findProperty(versionProperty.name());
       this.unloadProperties = derivePropertiesToUnload(prototypeEntityBean);
       this.propertiesIndex = new BeanProperty[ebi.getPropertyLength()];
       for (int i = 0; i < propertiesIndex.length; i++) {
@@ -452,8 +452,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the DatabaseConfig.
    */
-  public DatabaseConfig getConfig() {
-    return owner.getConfig();
+  public DatabaseConfig config() {
+    return owner.config();
   }
 
   /**
@@ -470,7 +470,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the EbeanServer instance that owns this BeanDescriptor.
    */
-  public SpiEbeanServer getEbeanServer() {
+  public SpiEbeanServer ebeanServer() {
     return ebeanServer;
   }
 
@@ -492,11 +492,11 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the type of this domain object.
    */
-  public EntityType getEntityType() {
+  public EntityType entityType() {
     return entityType;
   }
 
-  private String[] getProperties() {
+  private String[] properties() {
     return properties;
   }
 
@@ -545,7 +545,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
       for (BeanPropertyAssocMany<?> manyToMany : propertiesManyToMany) {
         // register associated history table for M2M intersection
         if (!manyToMany.isExcludedFromHistory()) {
-          TableJoin intersectionTableJoin = manyToMany.getIntersectionTableJoin();
+          TableJoin intersectionTableJoin = manyToMany.intersectionTableJoin();
           initContext.addHistoryIntersection(intersectionTableJoin.getTable());
         }
       }
@@ -570,8 +570,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     whereIdInSql = " where " + idBinderInLHSSqlNoAlias + " ";
     deleteByIdInSql = "delete from " + baseTable + whereIdInSql;
     if (softDelete) {
-      softDeleteByIdSql = "update " + baseTable + " set " + getSoftDeleteDbSet() + " where " + idEqualsSql;
-      softDeleteByIdInSql = "update " + baseTable + " set " + getSoftDeleteDbSet() + " where " + idBinderInLHSSqlNoAlias + " ";
+      softDeleteByIdSql = "update " + baseTable + " set " + softDeleteDbSet() + " where " + idEqualsSql;
+      softDeleteByIdInSql = "update " + baseTable + " set " + softDeleteDbSet() + " where " + idBinderInLHSSqlNoAlias + " ";
     } else {
       softDeleteByIdSql = null;
       softDeleteByIdInSql = null;
@@ -584,7 +584,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     if (naturalKey != null && naturalKey.length != 0) {
       BeanProperty[] props = new BeanProperty[naturalKey.length];
       for (int i = 0; i < naturalKey.length; i++) {
-        props[i] = getBeanProperty(naturalKey[i]);
+        props[i] = beanProperty(naturalKey[i]);
       }
       this.beanNaturalKey = new BeanNaturalKey(naturalKey, props);
     }
@@ -601,7 +601,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
 
   boolean hasCircularImportedIdTo(BeanDescriptor<?> sourceDesc) {
     for (BeanPropertyAssocOne<?> assocOne : propertiesOneImportedSave) {
-      if (assocOne.getTargetDescriptor() == sourceDesc) {
+      if (assocOne.targetDescriptor() == sourceDesc) {
         return true;
       }
     }
@@ -731,10 +731,10 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     EntityBeanIntercept fromEbi = bean._ebean_getIntercept();
     EntityBeanIntercept toEbi = existing._ebean_getIntercept();
     int propertyLength = toEbi.getPropertyLength();
-    String[] names = getProperties();
+    String[] names = properties();
     for (int i = 0; i < propertyLength; i++) {
       if (fromEbi.isLoadedProperty(i)) {
-        BeanProperty property = getBeanProperty(names[i]);
+        BeanProperty property = beanProperty(names[i]);
         if (!toEbi.isLoadedProperty(i)) {
           Object val = property.getValue(bean);
           property.setValue(existing, val);
@@ -758,15 +758,15 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the ReadAuditLogger for logging read audit events.
    */
-  public ReadAuditLogger getReadAuditLogger() {
-    return ebeanServer.getReadAuditLogger();
+  public ReadAuditLogger readAuditLogger() {
+    return ebeanServer.readAuditLogger();
   }
 
   /**
    * Return the ReadAuditPrepare for preparing read audit events prior to logging.
    */
-  private ReadAuditPrepare getReadAuditPrepare() {
-    return ebeanServer.getReadAuditPrepare();
+  private ReadAuditPrepare readAuditPrepare() {
+    return ebeanServer.readAuditPrepare();
   }
 
   public boolean isChangeLog() {
@@ -776,8 +776,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return true if this request should be included in the change log.
    */
-  public BeanChange getChangeLogBean(PersistRequestBean<T> request) {
-    switch (request.getType()) {
+  public BeanChange changeLogBean(PersistRequestBean<T> request) {
+    switch (request.type()) {
       case INSERT:
         return changeLogFilter.includeInsert(request) ? insertBeanChange(request) : null;
       case UPDATE:
@@ -786,7 +786,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
       case DELETE:
         return changeLogFilter.includeDelete(request) ? deleteBeanChange(request) : null;
       default:
-        throw new IllegalStateException("Unhandled request type " + request.getType());
+        throw new IllegalStateException("Unhandled request type " + request.type());
     }
   }
 
@@ -799,7 +799,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the bean change for a delete.
    */
   private BeanChange deleteBeanChange(PersistRequestBean<T> request) {
-    return beanChange(ChangeType.DELETE, request.getBeanId(), null, null);
+    return beanChange(ChangeType.DELETE, request.beanId(), null, null);
   }
 
   /**
@@ -808,9 +808,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   private BeanChange updateBeanChange(PersistRequestBean<T> request) {
     try {
       BeanChangeJson changeJson = new BeanChangeJson(this, request.isStatelessUpdate());
-      request.getEntityBeanIntercept().addDirtyPropertyValues(changeJson);
+      request.intercept().addDirtyPropertyValues(changeJson);
       changeJson.flush();
-      return beanChange(ChangeType.UPDATE, request.getBeanId(), changeJson.newJson(), changeJson.oldJson());
+      return beanChange(ChangeType.UPDATE, request.beanId(), changeJson.newJson(), changeJson.oldJson());
     } catch (RuntimeException e) {
       logger.error("Failed to write ChangeLog entry for update", e);
       return null;
@@ -824,9 +824,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     try {
       StringWriter writer = new StringWriter(200);
       SpiJsonWriter jsonWriter = createJsonWriter(writer);
-      jsonWriteForInsert(jsonWriter, request.getEntityBean());
+      jsonWriteForInsert(jsonWriter, request.entityBean());
       jsonWriter.flush();
-      return beanChange(ChangeType.INSERT, request.getBeanId(), writer.toString(), null);
+      return beanChange(ChangeType.INSERT, request.beanId(), writer.toString(), null);
     } catch (IOException e) {
       logger.error("Failed to write ChangeLog entry for insert", e);
       return null;
@@ -869,14 +869,14 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the "where id in" sql (for use with UpdateQuery).
    */
-  public String getWhereIdInSql() {
+  public String whereIdInSql() {
     return whereIdInSql;
   }
 
   /**
    * Return the "delete by id" sql.
    */
-  public String getDeleteByIdInSql() {
+  public String deleteByIdInSql() {
     return deleteByIdInSql;
   }
 
@@ -913,7 +913,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * foreign keys don't require an extra join.
    */
   public void add(BeanFkeyProperty fkey) {
-    elDeployCache.put(fkey.getName(), fkey);
+    elDeployCache.put(fkey.name(), fkey);
   }
 
   void initialiseFkeys() {
@@ -927,33 +927,33 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the cache options.
    */
-  public CacheOptions getCacheOptions() {
+  public CacheOptions cacheOptions() {
     return cacheHelp.getCacheOptions();
   }
 
   /**
    * Return the Encrypt key given the BeanProperty.
    */
-  public EncryptKey getEncryptKey(BeanProperty p) {
-    return owner.getEncryptKey(baseTable, p.getDbColumn());
+  public EncryptKey encryptKey(BeanProperty p) {
+    return owner.encryptKey(baseTable, p.dbColumn());
   }
 
   /**
    * Return the Encrypt key given the table and column name.
    */
-  public EncryptKey getEncryptKey(String tableName, String columnName) {
-    return owner.getEncryptKey(tableName, columnName);
+  public EncryptKey encryptKey(String tableName, String columnName) {
+    return owner.encryptKey(tableName, columnName);
   }
 
   /**
    * Return the Scalar type for the given JDBC type.
    */
-  public ScalarType<?> getScalarType(int jdbcType) {
-    return owner.getScalarType(jdbcType);
+  public ScalarType<?> scalarType(int jdbcType) {
+    return owner.scalarType(jdbcType);
   }
 
-  public ScalarType<?> getScalarType(String cast) {
-    return owner.getScalarType(cast);
+  public ScalarType<?> scalarType(String cast) {
+    return owner.scalarType(cast);
   }
 
   /**
@@ -967,7 +967,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the default select clause.
    */
-  public String getDefaultSelectClause() {
+  public String defaultSelectClause() {
     return defaultSelectClause;
   }
 
@@ -999,12 +999,12 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the queueId used to uniquely identify this type when queuing an index updateAdd.
    */
   @Override
-  public String getDocStoreQueueId() {
+  public String docStoreQueueId() {
     return docStoreQueueId;
   }
 
   @Override
-  public DocumentMapping getDocMapping() {
+  public DocumentMapping docMapping() {
     return docMapping;
   }
 
@@ -1067,7 +1067,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    */
   public String rootName() {
     if (inheritInfo != null && !inheritInfo.isRoot()) {
-      return inheritInfo.getRoot().desc().getName();
+      return inheritInfo.getRoot().desc().name();
     }
     return name;
   }
@@ -1075,14 +1075,14 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the named ORM query.
    */
-  public String getNamedQuery(String name) {
+  public String namedQuery(String name) {
     return namedQuery.get(name);
   }
 
   /**
    * Return the named RawSql query.
    */
-  public SpiRawSql getNamedRawSql(String named) {
+  public SpiRawSql namedRawSql(String named) {
     return namedRawSql.get(named);
   }
 
@@ -1090,7 +1090,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the type of DocStoreMode that should occur for this type of persist request
    * given the transactions requested mode.
    */
-  public DocStoreMode getDocStoreMode(PersistRequest.Type persistType, DocStoreMode txnMode) {
+  public DocStoreMode docStoreMode(PersistRequest.Type persistType, DocStoreMode txnMode) {
     return docStoreAdapter.getMode(persistType, txnMode);
   }
 
@@ -1127,7 +1127,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the draft dirty boolean property or null if there is not one assigned to this bean type.
    */
-  BeanProperty getDraftDirty() {
+  BeanProperty draftDirty() {
     return draftDirty;
   }
 
@@ -1149,7 +1149,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the natural key.
    */
-  public BeanNaturalKey getNaturalKey() {
+  public BeanNaturalKey naturalKey() {
     return beanNaturalKey;
   }
 
@@ -1421,13 +1421,13 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Write a bean read to the read audit log.
    */
   public void readAuditBean(String queryKey, String bindLog, Object bean) {
-    ReadEvent event = new ReadEvent(fullName, queryKey, bindLog, getIdForJson(bean));
+    ReadEvent event = new ReadEvent(fullName, queryKey, bindLog, idForJson(bean));
     readAuditPrepare(event);
-    getReadAuditLogger().auditBean(event);
+    readAuditLogger().auditBean(event);
   }
 
   private void readAuditPrepare(ReadEvent event) {
-    ReadAuditPrepare prepare = getReadAuditPrepare();
+    ReadAuditPrepare prepare = readAuditPrepare();
     if (prepare != null) {
       prepare.prepare(event);
     }
@@ -1439,7 +1439,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   public void readAuditMany(String queryKey, String bindLog, List<Object> ids) {
     ReadEvent event = new ReadEvent(fullName, queryKey, bindLog, ids);
     readAuditPrepare(event);
-    getReadAuditLogger().auditMany(event);
+    readAuditLogger().auditMany(event);
   }
 
   /**
@@ -1447,13 +1447,13 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    */
   public void readAuditFutureMany(ReadEvent event) {
     // this has already been prepared (in foreground thread)
-    getReadAuditLogger().auditMany(event);
+    readAuditLogger().auditMany(event);
   }
 
   /**
    * Return the base table alias. This is always the first letter of the bean name.
    */
-  public String getBaseTableAlias() {
+  public String baseTableAlias() {
     return baseTableAlias;
   }
 
@@ -1530,32 +1530,32 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     }
   }
 
-  public CQueryPlan getQueryPlan(CQueryPlanKey key) {
+  public CQueryPlan queryPlan(CQueryPlanKey key) {
     return queryPlanCache.get(key);
   }
 
-  public void putQueryPlan(CQueryPlanKey key, CQueryPlan plan) {
+  public void queryPlan(CQueryPlanKey key, CQueryPlan plan) {
     queryPlanCache.put(key, plan);
   }
 
   /**
    * Get a UpdatePlan for a given hash.
    */
-  public SpiUpdatePlan getUpdatePlan(String key) {
+  public SpiUpdatePlan updatePlan(String key) {
     return updatePlanCache.get(key);
   }
 
   /**
    * Add a UpdatePlan to the cache with a given hash.
    */
-  public void putUpdatePlan(String key, SpiUpdatePlan plan) {
+  public void updatePlan(String key, SpiUpdatePlan plan) {
     updatePlanCache.put(key, plan);
   }
 
   /**
    * Return a Sql update statement to set the importedId value (deferred execution).
    */
-  public String getUpdateImportedIdSql(ImportedId prop) {
+  public String updateImportedIdSql(ImportedId prop) {
     return "update " + baseTable + " set " + prop.importedIdClause() + " where " + idBinder.getBindIdSql(null);
   }
 
@@ -1597,7 +1597,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the 'when modified' property if there is one defined.
    */
   @Override
-  public BeanProperty getWhenModifiedProperty() {
+  public BeanProperty whenModifiedProperty() {
     return whenModifiedProperty;
   }
 
@@ -1605,7 +1605,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the 'when created' property if there is one defined.
    */
   @Override
-  public BeanProperty getWhenCreatedProperty() {
+  public BeanProperty whenCreatedProperty() {
     return whenCreatedProperty;
   }
 
@@ -1636,10 +1636,10 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the many property included in the query or null if one is not.
    */
-  public BeanPropertyAssocMany<?> getManyProperty(SpiQuery<?> query) {
+  public BeanPropertyAssocMany<?> manyProperty(SpiQuery<?> query) {
     OrmQueryDetail detail = query.getDetail();
     for (BeanPropertyAssocMany<?> many : propertiesMany) {
-      if (detail.includesPath(many.getName())) {
+      if (detail.includesPath(many.name())) {
         return many;
       }
     }
@@ -1649,7 +1649,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return a raw expression for 'where parent id in ...' clause.
    */
-  String getParentIdInExpr(int parentIdSize, String rawWhere) {
+  String parentIdInExpr(int parentIdSize, String rawWhere) {
     String inClause = idBinder.getIdInValueExpr(false, parentIdSize);
     return idBinder.isIdInExpandedForm() ? inClause : rawWhere + inClause;
   }
@@ -1658,7 +1658,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the IdBinder which is helpful for handling the various types of Id.
    */
   @Override
-  public IdBinder getIdBinder() {
+  public IdBinder idBinder() {
     return idBinder;
   }
 
@@ -1699,7 +1699,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the sql for binding an id. This is the columns with table alias that
    * make up the id.
    */
-  public String getIdBinderIdSql(String alias) {
+  public String idBinderIdSql(String alias) {
     if (alias == null) {
       return idBinderIdSql;
     } else {
@@ -1710,7 +1710,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the sql for binding id's using an IN clause.
    */
-  public String getIdBinderInLHSSql() {
+  public String idBinderInLHSSql() {
     return idBinderInLHSSql;
   }
 
@@ -1728,7 +1728,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * <p>
    * This 'flattens' any EmbeddedId or multiple Id property cases.
    */
-  public Object[] getBindIdValues(Object idValue) {
+  public Object[] bindIdValues(Object idValue) {
     return idBinder.getBindValues(idValue);
   }
 
@@ -1747,7 +1747,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    */
   private EntityBean createEntityBean(boolean isNew) {
     if (prototypeEntityBean == null) {
-      throw new UnsupportedOperationException("cannot create entity bean for abstract entity " + getName());
+      throw new UnsupportedOperationException("cannot create entity bean for abstract entity " + name());
     }
     try {
       EntityBean bean = (EntityBean) prototypeEntityBean._ebean_newInstance();
@@ -1793,7 +1793,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * We actually need to do a query because we don't know the type without the discriminator value.
    */
   private T findReferenceBean(Object id, PersistenceContext pc) {
-    DefaultOrmQuery<T> query = new DefaultOrmQuery<>(this, ebeanServer, ebeanServer.getExpressionFactory());
+    DefaultOrmQuery<T> query = new DefaultOrmQuery<>(this, ebeanServer, ebeanServer.expressionFactory());
     query.setPersistenceContext(pc);
     return query.setId(id).findOne();
   }
@@ -1904,21 +1904,21 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
       if (assocProp == null) {
         throw new IllegalStateException("Unknown property path [" + split[0] + "] from[" + path + "]");
       }
-      BeanDescriptor<?> targetDesc = assocProp.getTargetDescriptor();
+      BeanDescriptor<?> targetDesc = assocProp.targetDescriptor();
       path = split[1];
       other = targetDesc;
     }
   }
 
   @Override
-  public BeanType<?> getBeanTypeAtPath(String path) {
-    return getBeanDescriptor(path);
+  public BeanType<?> beanTypeAtPath(String path) {
+    return descriptor(path);
   }
 
   /**
    * Return the BeanDescriptor for a given path of Associated One or Many beans.
    */
-  public BeanDescriptor<?> getBeanDescriptor(String path) {
+  public BeanDescriptor<?> descriptor(String path) {
     BeanDescriptor<?> result = this;
     while (true) {
       if (path == null) {
@@ -1929,9 +1929,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
       if (beanProperty instanceof BeanPropertyAssoc<?>) {
         BeanPropertyAssoc<?> assocProp = (BeanPropertyAssoc<?>) beanProperty;
         path = splitBegin[1];
-        result = assocProp.getTargetDescriptor();
+        result = assocProp.targetDescriptor();
       } else {
-        throw new PersistenceException("Invalid path " + path + " from " + result.getFullName());
+        throw new PersistenceException("Invalid path " + path + " from " + result.fullName());
       }
     }
   }
@@ -1939,8 +1939,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the BeanDescriptor of another bean type.
    */
-  public <U> BeanDescriptor<U> getBeanDescriptor(Class<U> otherType) {
-    return owner.getBeanDescriptor(otherType);
+  public <U> BeanDescriptor<U> descriptor(Class<U> otherType) {
+    return owner.descriptor(otherType);
   }
 
   /**
@@ -1953,7 +1953,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the order column property.
    */
-  public BeanProperty getOrderColumn() {
+  public BeanProperty orderColumn() {
     return orderColumn;
   }
 
@@ -1964,7 +1964,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * relationships we have this 'shadow' property which is not externally
    * visible.
    */
-  public BeanPropertyAssocOne<?> getUnidirectional() {
+  public BeanPropertyAssocOne<?> unidirectional() {
     BeanDescriptor<?> other = this;
     while (true) {
       if (other.unidirectional != null) {
@@ -1991,7 +1991,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return bean class name.
    */
-  public String getDescriptorId() {
+  public String descriptorId() {
     return fullName;
   }
 
@@ -2000,7 +2000,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    */
   @Override
   @Nonnull
-  public Class<T> getBeanType() {
+  public Class<T> type() {
     return beanType;
   }
 
@@ -2012,7 +2012,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    */
   @Override
   @Nonnull
-  public String getFullName() {
+  public String fullName() {
     return fullName;
   }
 
@@ -2021,14 +2021,14 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    */
   @Override
   @Nonnull
-  public String getName() {
+  public String name() {
     return name;
   }
 
   /**
    * Return the simple name of the entity bean.
    */
-  public String getSimpleName() {
+  public String simpleName() {
     return beanType.getSimpleName();
   }
 
@@ -2093,8 +2093,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the Id property name or null if no Id property exists.
    */
-  public String getIdName() {
-    return (idProperty == null) ? null : idProperty.getName();
+  public String idName() {
+    return (idProperty == null) ? null : idProperty.name();
   }
 
   /**
@@ -2122,7 +2122,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   }
 
   @Override
-  public Object beanId(Object bean) {
+  public Object id(Object bean) {
     return getId((EntityBean) bean);
   }
 
@@ -2136,7 +2136,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * <p>
    * The usage is to provide simple id types for JSON processing (for embeddedId's).
    */
-  public Object getIdForJson(Object bean) {
+  public Object idForJson(Object bean) {
     return idBinder.getIdForJson((EntityBean) bean);
   }
 
@@ -2153,7 +2153,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the default order by that may need to be added if a many property is
    * included in the query.
    */
-  public String getDefaultOrderBy() {
+  public String defaultOrderBy() {
     return idBinder.getDefaultOrderBy();
   }
 
@@ -2168,7 +2168,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Set the bean id value converting if necessary.
    */
   @Override
-  public void setBeanId(T bean, Object idValue) {
+  public void setId(T bean, Object idValue) {
     idBinder.convertSetId(idValue, (EntityBean) bean);
   }
 
@@ -2190,22 +2190,22 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   }
 
   @Override
-  public Property getProperty(String propName) {
+  public Property property(String propName) {
     return findProperty(propName);
   }
 
   /**
    * Get a BeanProperty by its name.
    */
-  public BeanProperty getBeanProperty(String propName) {
+  public BeanProperty beanProperty(String propName) {
     return propMap.get(propName);
   }
 
   public void sort(List<T> list, String sortByClause) {
-    list.sort(getElComparator(sortByClause));
+    list.sort(elComparator(sortByClause));
   }
 
-  public ElComparator<T> getElComparator(String propNameOrSortBy) {
+  public ElComparator<T> elComparator(String propNameOrSortBy) {
     return comparatorCache.computeIfAbsent(propNameOrSortBy, this::createComparator);
   }
 
@@ -2217,10 +2217,10 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   public void lazyLoadRegister(String prefix, EntityBeanIntercept ebi, EntityBean bean, LoadContext loadContext) {
     // load the List/Set/Map proxy objects (deferred fetching of lists)
     for (BeanPropertyAssocMany<?> many : propertiesMany()) {
-      if (!ebi.isLoadedProperty(many.getPropertyIndex())) {
+      if (!ebi.isLoadedProperty(many.propertyIndex())) {
         BeanCollection<?> ref = many.createReferenceIfNull(bean);
         if (ref != null && !ref.isRegisteredWithLoadContext()) {
-          String path = SplitName.add(prefix, many.getName());
+          String path = SplitName.add(prefix, many.name());
           loadContext.register(path, many, ref);
         }
       }
@@ -2301,7 +2301,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   }
 
   private ElComparator<T> createPropertyComparator(SortByClause.Property sortProp) {
-    ElPropertyValue elGetValue = getElGetValue(sortProp.getName());
+    ElPropertyValue elGetValue = elGetValue(sortProp.getName());
     if (elGetValue == null) {
       logger.error("Sort property [" + sortProp + "] not found in " + beanType + ". Cannot sort.");
       return new ElComparatorNoop<>();
@@ -2320,7 +2320,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   @Override
   public boolean isValidExpression(String propertyName) {
     try {
-      return (getElGetValue(propertyName) != null);
+      return (elGetValue(propertyName) != null);
     } catch (PersistenceException e) {
       return false;
     }
@@ -2329,7 +2329,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Get an Expression language Value object.
    */
-  public ElPropertyValue getElGetValue(String propName) {
+  public ElPropertyValue elGetValue(String propName) {
     ElPropertyValue elGetValue = elCache.get(propName);
     if (elGetValue != null) {
       return elGetValue;
@@ -2342,8 +2342,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   }
 
   @Override
-  public ExpressionPath getExpressionPath(String path) {
-    return getElGetValue(path);
+  public ExpressionPath expressionPath(String path) {
+    return elGetValue(path);
   }
 
   /**
@@ -2351,7 +2351,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * <p>
    * The foreign key shortcuts means we can avoid unnecessary joins.
    */
-  public ElPropertyDeploy getElPropertyDeploy(String propName) {
+  public ElPropertyDeploy elPropertyDeploy(String propName) {
     ElPropertyDeploy elProp = elDeployCache.get(propName);
     if (elProp != null) {
       return elProp;
@@ -2359,7 +2359,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     if (!propName.contains(".")) {
       // No period means simple property and no need to look for
       // foreign key properties (in order to avoid an extra join)
-      elProp = getElGetValue(propName);
+      elProp = elGetValue(propName);
     } else {
       elProp = buildElGetValue(propName, null, true);
     }
@@ -2414,9 +2414,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
       assocProperty = tablePath.get(schemaName + "." + tableName);
     }
     if (assocProperty != null) {
-      String relativePath = assocProperty.getTargetDescriptor().findBeanPath(schemaName, tableName, columnName);
+      String relativePath = assocProperty.targetDescriptor().findBeanPath(schemaName, tableName, columnName);
       if (relativePath != null) {
-        return SplitName.add(assocProperty.getName(), relativePath);
+        return SplitName.add(assocProperty.name(), relativePath);
       }
     }
     return null;
@@ -2510,7 +2510,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * of bean is not involved in any ORM inheritance mapping.
    */
   @Override
-  public InheritInfo getInheritInfo() {
+  public InheritInfo inheritInfo() {
     return inheritInfo;
   }
 
@@ -2520,14 +2520,14 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   }
 
   @Override
-  public String getDiscColumn() {
+  public String discColumn() {
     return inheritInfo.getDiscriminatorColumn();
   }
 
   /**
    * Return the discriminator value for this bean type (or null when there is no inheritance).
    */
-  public String getDiscValue() {
+  public String discValue() {
     return inheritInfo == null ? null : inheritInfo.getDiscriminatorStringValue();
   }
 
@@ -2554,7 +2554,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the compound unique constraints.
    */
-  public IndexDefinition[] getIndexDefinitions() {
+  public IndexDefinition[] indexDefinitions() {
     return indexDefinitions;
   }
 
@@ -2562,14 +2562,14 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the beanListener.
    */
   @Override
-  public BeanPersistListener getPersistListener() {
+  public BeanPersistListener persistListener() {
     return persistListener;
   }
 
   /**
    * Return the beanFinder (Migrate over to getFindController).
    */
-  public BeanFindController getBeanFinder() {
+  public BeanFindController beanFinder() {
     return beanFinder;
   }
 
@@ -2577,7 +2577,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the find controller (SPI interface).
    */
   @Override
-  public BeanFindController getFindController() {
+  public BeanFindController findController() {
     return beanFinder;
   }
 
@@ -2585,7 +2585,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the BeanQueryAdapter or null if none is defined.
    */
   @Override
-  public BeanQueryAdapter getQueryAdapter() {
+  public BeanQueryAdapter queryAdapter() {
     return queryAdapter;
   }
 
@@ -2661,7 +2661,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the Controller.
    */
   @Override
-  public BeanPersistController getPersistController() {
+  public BeanPersistController persistController() {
     return persistController;
   }
 
@@ -2676,7 +2676,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the DB comment for the base table.
    */
-  public String getDbComment() {
+  public String dbComment() {
     return dbComment;
   }
 
@@ -2690,21 +2690,21 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the partition details of the bean.
    */
-  public PartitionMeta getPartitionMeta() {
+  public PartitionMeta partitionMeta() {
     return partitionMeta;
   }
 
   /**
    * Return the storage engine.
    */
-  public String getStorageEngine() {
+  public String storageEngine() {
     return storageEngine;
   }
 
   /**
    * Return the dependent tables for a view based entity.
    */
-  public String[] getDependentTables() {
+  public String[] dependentTables() {
     return dependentTables;
   }
 
@@ -2712,7 +2712,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the base table. Only properties mapped to the base table are by default persisted.
    */
   @Override
-  public String getBaseTable() {
+  public String baseTable() {
     return baseTable;
   }
 
@@ -2727,7 +2727,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the base table to use given the query temporal mode.
    */
   @Override
-  public String getBaseTable(SpiQuery.TemporalMode mode) {
+  public String baseTable(SpiQuery.TemporalMode mode) {
     switch (mode) {
       case DRAFT:
         return draftTable;
@@ -2743,7 +2743,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the associated draft table.
    */
-  public String getDraftTable() {
+  public String draftTable() {
     return draftTable;
   }
 
@@ -2759,27 +2759,27 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     return softDelete;
   }
 
-  public void setSoftDeleteValue(EntityBean bean) {
+  public void softDeleteValue(EntityBean bean) {
     softDeleteProperty.setSoftDeleteValue(bean);
   }
 
-  String getSoftDeleteDbSet() {
-    return softDeleteProperty.getSoftDeleteDbSet();
+  String softDeleteDbSet() {
+    return softDeleteProperty.softDeleteDbSet();
   }
 
   @Override
-  public String getSoftDeletePredicate(String tableAlias) {
-    return softDeleteProperty.getSoftDeleteDbPredicate(tableAlias);
+  public String softDeletePredicate(String tableAlias) {
+    return softDeleteProperty.softDeleteDbPredicate(tableAlias);
   }
 
   @Override
   public void markAsDeleted(EntityBean bean) {
     if (softDeleteProperty == null) {
       Object id = getId(bean);
-      logger.info("(Lazy) loading unsuccessful for type:{} id:{} - expecting when bean has been deleted", getName(), id);
+      logger.info("(Lazy) loading unsuccessful for type:{} id:{} - expecting when bean has been deleted", name(), id);
       bean._ebean_getIntercept().setLazyLoadFailure(id);
     } else {
-      setSoftDeleteValue(bean);
+      softDeleteValue(bean);
       bean._ebean_getIntercept().setLoaded();
       setAllLoaded(bean);
     }
@@ -2801,18 +2801,18 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
 
   @Override
   public boolean isEmbeddedPath(String propertyPath) {
-    ElPropertyDeploy elProp = getElPropertyDeploy(propertyPath);
+    ElPropertyDeploy elProp = elPropertyDeploy(propertyPath);
     if (elProp == null) {
-      throw new PersistenceException("Invalid path " + propertyPath + " from " + getFullName());
+      throw new PersistenceException("Invalid path " + propertyPath + " from " + fullName());
     }
-    return elProp.getBeanProperty().isEmbedded();
+    return elProp.beanProperty().isEmbedded();
   }
 
   @Override
   public ExtraJoin extraJoin(String propertyPath) {
-    ElPropertyValue elGetValue = getElGetValue(propertyPath);
+    ElPropertyValue elGetValue = elGetValue(propertyPath);
     if (elGetValue != null) {
-      BeanProperty beanProperty = elGetValue.getBeanProperty();
+      BeanProperty beanProperty = elGetValue.beanProperty();
       if (beanProperty instanceof BeanPropertyAssoc<?>) {
         BeanPropertyAssoc<?> assocProp = (BeanPropertyAssoc<?>) beanProperty;
         if (!assocProp.isEmbedded()) {
@@ -2825,7 +2825,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
 
   @Override
   public void inheritanceLoad(SqlBeanLoad sqlBeanLoad, STreeProperty property, DbReadContext ctx) {
-    BeanProperty p = getBeanProperty(property.getName());
+    BeanProperty p = beanProperty(property.name());
     if (p != null) {
       p.load(sqlBeanLoad);
     } else {
@@ -2874,7 +2874,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   public boolean isToManyDirty(EntityBean bean) {
     final EntityBeanIntercept ebi = bean._ebean_getIntercept();
     for (BeanPropertyAssocMany<?> many : propertiesManySave) {
-      if (ebi.isLoadedProperty(many.getPropertyIndex())) {
+      if (ebi.isLoadedProperty(many.propertyIndex())) {
         final BeanCollection<?> value = (BeanCollection<?>) many.getValue(bean);
         if (value != null && value.hasModifications()) {
           return true;
@@ -2902,7 +2902,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     if (draftDirty != null) {
       // check to see if the dirty property has already
       // been set and if so do not set the value
-      if (!entityBean._ebean_getIntercept().isChangedProperty(draftDirty.getPropertyIndex())) {
+      if (!entityBean._ebean_getIntercept().isChangedProperty(draftDirty.propertyIndex())) {
         draftDirty.setValueIntercept(entityBean, value);
       }
     }
@@ -2929,7 +2929,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the identity generation type.
    */
   @Override
-  public IdType getIdType() {
+  public IdType idType() {
     return idType;
   }
 
@@ -2952,7 +2952,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     return idGeneratedValue;
   }
 
-  public IdentityMode getIdentityMode() {
+  public IdentityMode identityMode() {
     return identityMode;
   }
 
@@ -2962,7 +2962,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * This is only used with Identity columns and getGeneratedKeys is not
    * supported.
    */
-  public String getSelectLastInsertedId(boolean publish) {
+  public String selectLastInsertedId(boolean publish) {
     return publish ? selectLastInsertedId : selectLastInsertedIdDraft;
   }
 
@@ -3026,7 +3026,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
       final Set<String> included = rootProps.getIncluded();
       if (included != null) {
         for (BeanProperty property : propertiesAggregate) {
-          if (included.contains(property.getName())) {
+          if (included.contains(property.name())) {
             return true;
           }
         }
@@ -3045,12 +3045,12 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     }
   }
 
-  public TableJoin getPrimaryKeyJoin() {
+  public TableJoin primaryKeyJoin() {
     return primaryKeyJoin;
   }
 
   @Override
-  public BeanProperty getIdProperty() {
+  public BeanProperty idProperty() {
     return idProperty;
   }
 
@@ -3087,7 +3087,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
 
   public boolean isIdLoaded(EntityBeanIntercept ebi) {
     // assume id loaded for IdClass case with idPropertyIndex == -1
-    return idPropertyIndex == -1 ? true : ebi.isLoadedProperty(idPropertyIndex);
+    return idPropertyIndex == -1 || ebi.isLoadedProperty(idPropertyIndex);
   }
 
   boolean hasIdValue(EntityBean bean) {
@@ -3124,7 +3124,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    */
   public void checkMutableProperties(EntityBeanIntercept ebi) {
     for (BeanProperty beanProperty : propertiesMutable) {
-      int propertyIndex = beanProperty.getPropertyIndex();
+      int propertyIndex = beanProperty.propertyIndex();
       if (ebi.isLoadedProperty(propertyIndex)) {
         Object value = beanProperty.getValue(ebi.getOwner());
         if (beanProperty.checkMutable(value, ebi.isDirtyProperty(propertyIndex), ebi)) {
@@ -3136,7 +3136,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     }
   }
 
-  public ConcurrencyMode getConcurrencyMode(EntityBeanIntercept ebi) {
+  public ConcurrencyMode concurrencyMode(EntityBeanIntercept ebi) {
     if (!hasVersionProperty(ebi)) {
       return ConcurrencyMode.NONE;
     } else {
@@ -3176,8 +3176,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * provides unique ordering of the rows (so that the paging is predicable).
    */
   public void appendOrderById(SpiQuery<T> query) {
-    if (idProperty != null && !idProperty.isEmbedded() && !query.order().containsProperty(idProperty.getName())) {
-      query.order().asc(idProperty.getName());
+    if (idProperty != null && !idProperty.isEmbedded() && !query.order().containsProperty(idProperty.name())) {
+      query.order().asc(idProperty.name());
     }
   }
 
@@ -3287,7 +3287,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * <p>
    * Note that this DOES NOT find a version property on an embedded bean.
    */
-  public BeanProperty getVersionProperty() {
+  public BeanProperty versionProperty() {
     return versionProperty;
   }
 
@@ -3301,7 +3301,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   /**
    * Return the tenant property when multi-tenant partitioning support is used.
    */
-  public BeanProperty getTenantProperty() {
+  public BeanProperty tenantProperty() {
     return tenant;
   }
 
@@ -3377,14 +3377,14 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     return jsonHelp.jsonRead(jsonRead, path, false);
   }
 
-  public List<BeanProperty[]> getUniqueProps() {
+  public List<BeanProperty[]> uniqueProps() {
     return propertiesUnique;
   }
 
   @Override
-  public List<BeanType<?>> getInheritanceChildren() {
+  public List<BeanType<?>> inheritanceChildren() {
     if (hasInheritance()) {
-      return getInheritInfo().getChildren()
+      return inheritInfo().getChildren()
         .stream()
         .map(InheritInfo::desc)
         .collect(Collectors.toList());
@@ -3394,14 +3394,14 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   }
 
   @Override
-  public BeanType<?> getInheritanceParent() {
-    return getInheritInfo() == null ? null : getInheritInfo().getParent().desc();
+  public BeanType<?> inheritanceParent() {
+    return inheritInfo() == null ? null : inheritInfo().getParent().desc();
   }
 
   @Override
   public void visitAllInheritanceChildren(Consumer<BeanType<?>> visitor) {
     if (hasInheritance()) {
-      getInheritInfo().visitChildren(info -> visitor.accept(info.desc()));
+      inheritInfo().visitChildren(info -> visitor.accept(info.desc()));
     }
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorCacheHelp.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorCacheHelp.java
index 7cdaf95df..66ea0ffef 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorCacheHelp.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorCacheHelp.java
@@ -124,7 +124,7 @@ final class BeanDescriptorCacheHelp<T> {
       if (cacheNotifyOnAll || cacheNotifyOnDelete) {
         String notifyMode = cacheNotifyOnAll ? "All" : "Delete";
         logger.debug("l2 caching on {} - beanCaching:{} queryCaching:{} notifyMode:{} ",
-          desc.getFullName(), isBeanCaching(), isQueryCaching(), notifyMode);
+          desc.fullName(), isBeanCaching(), isQueryCaching(), notifyMode);
       }
     }
   }
@@ -282,7 +282,7 @@ final class BeanDescriptorCacheHelp<T> {
       // held as part of the bean cache so skip
       return false;
     }
-    CachedManyIds entry = manyPropGet(parentId, many.getName());
+    CachedManyIds entry = manyPropGet(parentId, many.name());
     if (entry == null) {
       // not in cache so return unsuccessful
       return false;
@@ -290,7 +290,7 @@ final class BeanDescriptorCacheHelp<T> {
     EntityBean ownerBean = bc.getOwnerBean();
     EntityBeanIntercept ebi = ownerBean._ebean_getIntercept();
     PersistenceContext persistenceContext = ebi.getPersistenceContext();
-    BeanDescriptor<?> targetDescriptor = many.getTargetDescriptor();
+    BeanDescriptor<?> targetDescriptor = many.targetDescriptor();
 
     List<Object> idList = entry.getIdList();
     bc.checkEmptyLazyLoad();
@@ -316,7 +316,7 @@ final class BeanDescriptorCacheHelp<T> {
           // add as JSON to bean cache
           String asJson = many.jsonWriteCollection(details);
           Map<String, Object> changes = new HashMap<>();
-          changes.put(many.getName(), asJson);
+          changes.put(many.name(), asJson);
 
           CachedBeanData newData = data.update(changes, data.getVersion());
           if (beanLog.isDebugEnabled()) {
@@ -330,7 +330,7 @@ final class BeanDescriptorCacheHelp<T> {
     } else {
       CachedManyIds entry = createManyIds(many, details);
       if (entry != null) {
-        cachePutManyIds(parentId, many.getName(), entry);
+        cachePutManyIds(parentId, many.name(), entry);
       }
     }
   }
@@ -349,10 +349,10 @@ final class BeanDescriptorCacheHelp<T> {
       return null;
     }
 
-    BeanDescriptor<?> targetDescriptor = many.getTargetDescriptor();
+    BeanDescriptor<?> targetDescriptor = many.targetDescriptor();
     List<Object> idList = new ArrayList<>(actualDetails.size());
     for (Object bean : actualDetails) {
-      idList.add(targetDescriptor.getId((EntityBean) bean));
+      idList.add(targetDescriptor.id(bean));
     }
     return new CachedManyIds(idList);
   }
@@ -375,7 +375,7 @@ final class BeanDescriptorCacheHelp<T> {
     for (Map.Entry<Object, Object> entry : beanDataMap.entrySet()) {
       CachedBeanData cachedBeanData = (CachedBeanData) entry.getValue();
       T bean = convertToBean(entry.getKey(), false, context, cachedBeanData);
-      result.add(bean, desc.getBeanId(bean));
+      result.add(bean, desc.id(bean));
     }
     return result;
   }
@@ -773,7 +773,7 @@ final class BeanDescriptorCacheHelp<T> {
 
   void cacheUpdateQuery(boolean update, SpiTransaction transaction) {
     if (invalidateQueryCache || cacheNotifyOnAll || (!update && cacheNotifyOnDelete)) {
-      transaction.getEvent().add(desc.getBaseTable(), false, update, !update);
+      transaction.getEvent().add(desc.baseTable(), false, update, !update);
     }
   }
 
@@ -803,7 +803,7 @@ final class BeanDescriptorCacheHelp<T> {
       if (beanCache != null) {
         changeSet.addBeanRemove(desc, id);
       }
-      cacheDeleteImported(true, deleteRequest.getEntityBean(), changeSet);
+      cacheDeleteImported(true, deleteRequest.entityBean(), changeSet);
     }
   }
 
@@ -815,8 +815,8 @@ final class BeanDescriptorCacheHelp<T> {
       changeSet.addInvalidate(desc);
     } else {
       queryCacheClear(changeSet);
-      cacheDeleteImported(false, insertRequest.getEntityBean(), changeSet);
-      changeSet.addBeanInsert(desc.getBaseTable());
+      cacheDeleteImported(false, insertRequest.entityBean(), changeSet);
+      changeSet.addBeanInsert(desc.baseTable());
     }
   }
 
@@ -839,13 +839,13 @@ final class BeanDescriptorCacheHelp<T> {
         // query caching only
         return;
       }
-      List<BeanPropertyAssocMany<?>> manyCollections = updateRequest.getUpdatedManyForL2Cache();
+      List<BeanPropertyAssocMany<?>> manyCollections = updateRequest.updatedManyForL2Cache();
       if (manyCollections != null) {
         for (BeanPropertyAssocMany<?> many : manyCollections) {
-          Object details = many.getValue(updateRequest.getEntityBean());
+          Object details = many.getValue(updateRequest.entityBean());
           CachedManyIds entry = createManyIds(many, details);
           if (entry != null) {
-            changeSet.addManyPut(desc, many.getName(), id, entry);
+            changeSet.addManyPut(desc, many.name(), id, entry);
           }
         }
       }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorDraftHelp.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorDraftHelp.java
index f1433dbde..f11a921c7 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorDraftHelp.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorDraftHelp.java
@@ -19,7 +19,7 @@ final class BeanDescriptorDraftHelp<T> {
 
   BeanDescriptorDraftHelp(BeanDescriptor<T> desc) {
     this.desc = desc;
-    this.draftDirty = desc.getDraftDirty();
+    this.draftDirty = desc.draftDirty();
     this.resetProperties = resetProperties();
   }
 
@@ -66,7 +66,7 @@ final class BeanDescriptorDraftHelp<T> {
     }
     EntityBean draft = (EntityBean) draftBean;
     EntityBean live = (EntityBean) liveBean;
-    BeanProperty idProperty = desc.getIdProperty();
+    BeanProperty idProperty = desc.idProperty();
     if (idProperty != null) {
       idProperty.publish(draft, live);
     }
@@ -74,7 +74,7 @@ final class BeanDescriptorDraftHelp<T> {
       prop.publish(draft, live);
     }
     for (BeanPropertyAssocMany<?> many : desc.propertiesMany()) {
-      if (many.getTargetDescriptor().isDraftable()) {
+      if (many.targetDescriptor().isDraftable()) {
         many.publishMany(draft, live);
       }
     }
@@ -86,13 +86,13 @@ final class BeanDescriptorDraftHelp<T> {
    */
   void draftQueryOptimise(Query<T> query) {
     for (BeanPropertyAssocOne<?> anOne : desc.propertiesOne()) {
-      if (anOne.getTargetDescriptor().isDraftableElement()) {
-        query.fetch(anOne.getName());
+      if (anOne.targetDescriptor().isDraftableElement()) {
+        query.fetch(anOne.name());
       }
     }
     for (BeanPropertyAssocMany<?> aMany : desc.propertiesMany()) {
-      if (aMany.getTargetDescriptor().isDraftableElement()) {
-        query.fetch(aMany.getName());
+      if (aMany.targetDescriptor().isDraftableElement()) {
+        query.fetch(aMany.name());
       }
     }
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElement.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElement.java
index 54803369a..c69fbb265 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElement.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElement.java
@@ -35,7 +35,7 @@ abstract class BeanDescriptorElement<T> extends BeanDescriptor<T> {
   }
 
   @Override
-  public String getSimpleName() {
+  public String simpleName() {
     return simpleName;
   }
 
@@ -52,7 +52,7 @@ abstract class BeanDescriptorElement<T> extends BeanDescriptor<T> {
     if (props.length != 1) {
       throw new IllegalStateException("Expecting 1 property for element scalar but got " + Arrays.toString(props));
     }
-    return props[0].getScalarType();
+    return props[0].scalarType();
   }
 
   /**
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElementEmbedded.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElementEmbedded.java
index 6758d4b09..5c620fd73 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElementEmbedded.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElementEmbedded.java
@@ -42,7 +42,7 @@ class BeanDescriptorElementEmbedded<T> extends BeanDescriptorElement<T> {
   @Override
   public void initialiseOther(BeanDescriptorInitContext initContext) {
     super.initialiseOther(initContext);
-    this.targetDescriptor = embeddedProperty.getTargetDescriptor();
+    this.targetDescriptor = embeddedProperty.targetDescriptor();
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElementScalarMap.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElementScalarMap.java
index 93a2bcb91..d9f6b4b25 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElementScalarMap.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorElementScalarMap.java
@@ -26,8 +26,8 @@ class BeanDescriptorElementScalarMap<T> extends BeanDescriptorElement<T> {
     if (props.length != 2) {
       throw new IllegalStateException("Expecting 2 properties for key and value but got " + Arrays.toString(props));
     }
-    this.scalarTypeKey = props[0].getScalarType();
-    this.scalarTypeVal = props[1].getScalarType();
+    this.scalarTypeKey = props[0].scalarType();
+    this.scalarTypeVal = props[1].scalarType();
     this.stringKey = String.class.equals(scalarTypeKey.getType());
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorJsonHelp.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorJsonHelp.java
index 091a5a579..5abb988c7 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorJsonHelp.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorJsonHelp.java
@@ -57,7 +57,7 @@ final class BeanDescriptorJsonHelp<T> {
     // render the dirty properties
     BeanProperty[] props = desc.propertiesNonTransient();
     for (BeanProperty prop : props) {
-      if (dirtyProps[prop.getPropertyIndex()]) {
+      if (dirtyProps[prop.propertyIndex()]) {
         prop.jsonWrite(writeJson, bean);
       }
     }
@@ -123,7 +123,7 @@ final class BeanDescriptorJsonHelp<T> {
       JsonToken event = parser.nextToken();
       if (JsonToken.FIELD_NAME == event) {
         String key = parser.getCurrentName();
-        BeanProperty p = desc.getBeanProperty(key);
+        BeanProperty p = desc.beanProperty(key);
         if (p != null) {
           p.jsonRead(readJson, bean);
         } else {
@@ -145,7 +145,7 @@ final class BeanDescriptorJsonHelp<T> {
       desc.setUnmappedJson(bean, unmappedProperties);
     }
     Object contextBean = null;
-    Object id = desc.beanId(bean);
+    Object id = desc.id(bean);
     if (!isNullOrZero(id)) {
       // check if the bean has already been loaded
       contextBean = readJson.persistenceContextPutIfAbsent(id, bean, desc);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorManager.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorManager.java
index 6261ab73c..74bcec97b 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorManager.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorManager.java
@@ -136,8 +136,8 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
     this.multiValueBind = config.getMultiValueBind();
     this.idBinderFactory = new IdBinderFactory(databasePlatform.isIdInExpandedForm(), multiValueBind);
     this.queryPlanTTLSeconds = this.config.getQueryPlanTTLSeconds();
-    this.asOfViewSuffix = getAsOfViewSuffix(databasePlatform, this.config);
-    String versionsBetweenSuffix = getVersionsBetweenSuffix(databasePlatform, this.config);
+    this.asOfViewSuffix = asOfViewSuffix(databasePlatform, this.config);
+    String versionsBetweenSuffix = versionsBetweenSuffix(databasePlatform, this.config);
     this.readAnnotations = new ReadAnnotations(config.getGeneratedPropertyFactory(), asOfViewSuffix, versionsBetweenSuffix, this.config);
     this.bootupClasses = config.getBootupClasses();
     this.createProperties = config.getDeployCreateProperties();
@@ -183,19 +183,19 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
   }
 
   @Override
-  public ScalarType<?> getScalarType(String cast) {
+  public ScalarType<?> scalarType(String cast) {
     return typeManager.getScalarType(cast);
   }
 
   @Override
-  public ScalarType<?> getScalarType(int jdbcType) {
+  public ScalarType<?> scalarType(int jdbcType) {
     return typeManager.getScalarType(jdbcType);
   }
 
   /**
    * Return the AsOfViewSuffix based on the DbHistorySupport.
    */
-  private String getAsOfViewSuffix(DatabasePlatform databasePlatform, DatabaseConfig serverConfig) {
+  private String asOfViewSuffix(DatabasePlatform databasePlatform, DatabaseConfig serverConfig) {
     DbHistorySupport historySupport = databasePlatform.getHistorySupport();
     // with historySupport returns a simple view suffix or the sql2011 as of timestamp suffix
     return (historySupport == null) ? serverConfig.getAsOfViewSuffix() : historySupport.getAsOfViewSuffix(serverConfig.getAsOfViewSuffix());
@@ -204,7 +204,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
   /**
    * Return the versions between timestamp suffix based on the DbHistorySupport.
    */
-  private String getVersionsBetweenSuffix(DatabasePlatform databasePlatform, DatabaseConfig serverConfig) {
+  private String versionsBetweenSuffix(DatabasePlatform databasePlatform, DatabaseConfig serverConfig) {
     DbHistorySupport historySupport = databasePlatform.getHistorySupport();
     // with historySupport returns a simple view suffix or the sql2011 versions between timestamp suffix
     return (historySupport == null) ? serverConfig.getAsOfViewSuffix() : historySupport.getVersionsBetweenSuffix(serverConfig.getAsOfViewSuffix());
@@ -216,7 +216,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
   }
 
   @Override
-  public DatabaseConfig getConfig() {
+  public DatabaseConfig config() {
     return config;
   }
 
@@ -225,38 +225,38 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
     return docStoreFactory.createAdapter(descriptor, deploy);
   }
 
-  public BeanDescriptor<?> getBeanDescriptorByQueueId(String queueId) {
+  public BeanDescriptor<?> descriptorByQueueId(String queueId) {
     return descQueueMap.get(queueId);
   }
 
   @Override
-  public SpiBeanType getBeanType(Class<?> entityType) {
-    return getBeanDescriptor(entityType);
+  public SpiBeanType beanType(Class<?> entityType) {
+    return descriptor(entityType);
   }
 
   @Override
   @SuppressWarnings("unchecked")
-  public <T> BeanDescriptor<T> getBeanDescriptor(Class<T> entityType) {
+  public <T> BeanDescriptor<T> descriptor(Class<T> entityType) {
     return (BeanDescriptor<T>) descMap.get(entityType.getName());
   }
 
   @SuppressWarnings("unchecked")
-  public <T> BeanDescriptor<T> getBeanDescriptorByClassName(String entityClassName) {
+  public <T> BeanDescriptor<T> descriptorByClassName(String entityClassName) {
     return (BeanDescriptor<T>) descMap.get(entityClassName);
   }
 
   @Override
-  public String getServerName() {
+  public String name() {
     return serverName;
   }
 
   @Override
-  public SpiCacheManager getCacheManager() {
+  public SpiCacheManager cacheManager() {
     return cacheManager;
   }
 
   @Override
-  public NamingConvention getNamingConvention() {
+  public NamingConvention namingConvention() {
     return namingConvention;
   }
 
@@ -277,7 +277,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
   /**
    * Return the map of base tables to draft tables.
    */
-  public Map<String, String> getDraftTableMap() {
+  public Map<String, String> draftTableMap() {
     return draftTableMap;
   }
 
@@ -369,7 +369,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
    * Return the Encrypt key given the table and column name.
    */
   @Override
-  public EncryptKey getEncryptKey(String tableName, String columnName) {
+  public EncryptKey encryptKey(String tableName, String columnName) {
     return encryptKeyManager.getEncryptKey(tableName, columnName);
   }
 
@@ -377,7 +377,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
    * For SQL based modifications we need to invalidate appropriate parts of the cache.
    */
   public void cacheNotify(TransactionEventTable.TableIUD tableIUD, CacheChangeSet changeSet) {
-    String tableName = tableIUD.getTableName().toLowerCase();
+    String tableName = tableIUD.tableName().toLowerCase();
     List<BeanDescriptor<?>> normalBeanTypes = tableToDescMap.get(tableName);
     if (normalBeanTypes != null) {
       // 'normal' entity beans based on a "base table"
@@ -397,14 +397,14 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
   /**
    * Return the BeanDescriptors mapped to the table.
    */
-  public List<BeanDescriptor<?>> getBeanDescriptors(String tableName) {
+  public List<BeanDescriptor<?>> descriptors(String tableName) {
     return tableToDescMap.get(tableName.toLowerCase());
   }
 
   /**
    * Return the BeanDescriptors mapped to the table.
    */
-  public List<? extends BeanType<?>> getBeanTypes(String tableName) {
+  public List<? extends BeanType<?>> beanTypes(String tableName) {
     return tableToDescMap.get(tableName.toLowerCase());
   }
 
@@ -433,16 +433,16 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
    */
   private void readTableToDescriptor() {
     for (BeanDescriptor<?> desc : descMap.values()) {
-      String baseTable = desc.getBaseTable();
+      String baseTable = desc.baseTable();
       if (baseTable != null) {
         baseTable = baseTable.toLowerCase();
         List<BeanDescriptor<?>> list = tableToDescMap.computeIfAbsent(baseTable, k -> new ArrayList<>(1));
         list.add(desc);
       }
-      if (desc.getEntityType() == EntityType.VIEW && desc.isQueryCaching()) {
+      if (desc.entityType() == EntityType.VIEW && desc.isQueryCaching()) {
         // build map of tables to view entities dependent on those tables
         // for the purpose of invalidating appropriate query caches
-        String[] dependentTables = desc.getDependentTables();
+        String[] dependentTables = desc.dependentTables();
         if (dependentTables != null && dependentTables.length > 0) {
           for (String depTable : dependentTables) {
             depTable = depTable.toLowerCase();
@@ -508,23 +508,23 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
     for (BeanDescriptor<?> d : descMap.values()) {
       d.initLast();
       if (!d.isEmbedded()) {
-        beanManagerMap.put(d.getFullName(), beanManagerFactory.create(d));
+        beanManagerMap.put(d.fullName(), beanManagerFactory.create(d));
         checkForValidEmbeddedId(d);
       }
     }
   }
 
   private void checkForValidEmbeddedId(BeanDescriptor<?> d) {
-    IdBinder idBinder = d.getIdBinder();
+    IdBinder idBinder = d.idBinder();
     if (idBinder instanceof IdBinderEmbedded) {
       IdBinderEmbedded embId = (IdBinderEmbedded) idBinder;
       BeanDescriptor<?> idBeanDescriptor = embId.getIdBeanDescriptor();
-      Class<?> idType = idBeanDescriptor.getBeanType();
+      Class<?> idType = idBeanDescriptor.type();
       try {
         idType.getDeclaredMethod("hashCode");
         idType.getDeclaredMethod("equals", Object.class);
       } catch (NoSuchMethodException e) {
-        checkMissingHashCodeOrEquals(e, idType, d.getBeanType());
+        checkMissingHashCodeOrEquals(e, idType, d.type());
       }
     }
   }
@@ -546,11 +546,11 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
   /**
    * Return an immutable list of all the BeanDescriptors.
    */
-  public List<BeanDescriptor<?>> getBeanDescriptorList() {
+  public List<BeanDescriptor<?>> descriptorList() {
     return immutableDescriptorList;
   }
 
-  public BeanTable getBeanTable(Class<?> type) {
+  public BeanTable beanTable(Class<?> type) {
     return beanTableMap.get(type);
   }
 
@@ -562,11 +562,11 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
   }
 
   @SuppressWarnings("unchecked")
-  public <T> BeanManager<T> getBeanManager(Class<T> entityType) {
-    return (BeanManager<T>) getBeanManager(entityType.getName());
+  public <T> BeanManager<T> beanManager(Class<T> entityType) {
+    return (BeanManager<T>) beanManager(entityType.getName());
   }
 
-  private BeanManager<?> getBeanManager(String beanClassName) {
+  private BeanManager<?> beanManager(String beanClassName) {
     return beanManagerMap.get(beanClassName);
   }
 
@@ -591,19 +591,19 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
    * Return the bean deploy info for the given class.
    */
   @SuppressWarnings("unchecked")
-  public <T> DeployBeanInfo<T> getDeploy(Class<T> cls) {
+  public <T> DeployBeanInfo<T> deploy(Class<T> cls) {
     return (DeployBeanInfo<T>) deployInfoMap.get(cls);
   }
 
-  private void registerBeanDescriptor(DeployBeanInfo<?> info) {
+  private void registerDescriptor(DeployBeanInfo<?> info) {
     BeanDescriptor<?> desc = new BeanDescriptor<>(this, info.getDescriptor());
-    descMap.put(desc.getBeanType().getName(), desc);
+    descMap.put(desc.type().getName(), desc);
     if (desc.isDocStoreMapped()) {
-      descQueueMap.put(desc.getDocStoreQueueId(), desc);
+      descQueueMap.put(desc.docStoreQueueId(), desc);
     }
     for (BeanPropertyAssocMany<?> many : desc.propertiesMany()) {
       if (many.isElementCollection()) {
-        elementDescriptors.add(many.getElementDescriptor());
+        elementDescriptors.add(many.elementDescriptor());
       }
     }
   }
@@ -640,7 +640,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
 
   private void registerEmbeddedBean(DeployBeanInfo<?> info) {
     readDeployAssociations(info);
-    registerBeanDescriptor(info);
+    registerDescriptor(info);
   }
 
   /**
@@ -711,7 +711,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
     }
     for (DeployBeanInfo<?> info : deployInfoMap.values()) {
       if (!info.isEmbedded()) {
-        registerBeanDescriptor(info);
+        registerDescriptor(info);
       }
     }
   }
@@ -785,7 +785,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
     }
   }
 
-  private DeployBeanDescriptor<?> getTargetDescriptor(DeployBeanPropertyAssoc<?> prop) {
+  private DeployBeanDescriptor<?> targetDescriptor(DeployBeanPropertyAssoc<?> prop) {
     Class<?> targetType = prop.getTargetType();
     DeployBeanInfo<?> info = deployInfoMap.get(targetType);
     if (info == null) {
@@ -805,7 +805,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
     Set<String> matchSet = new HashSet<>();
 
     // get the bean descriptor that holds the mappedBy property
-    DeployBeanDescriptor<?> targetDesc = getTargetDescriptor(prop);
+    DeployBeanDescriptor<?> targetDesc = targetDescriptor(prop);
     List<DeployBeanPropertyAssocOne<?>> ones = targetDesc.propertiesAssocOne();
     for (DeployBeanPropertyAssocOne<?> possibleMappedBy : ones) {
       Class<?> possibleMappedByType = possibleMappedBy.getTargetType();
@@ -866,7 +866,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
   }
 
   private void makeOrderColumn(DeployBeanPropertyAssocMany<?> oneToMany) {
-    DeployBeanDescriptor<?> targetDesc = getTargetDescriptor(oneToMany);
+    DeployBeanDescriptor<?> targetDesc = targetDescriptor(oneToMany);
     DeployOrderColumn orderColumn = oneToMany.getOrderColumn();
     final ScalarType<?> scalarType = typeManager.getScalarType(Integer.class);
     DeployBeanProperty orderProperty = new DeployBeanProperty(targetDesc, Integer.class, scalarType, null);
@@ -898,7 +898,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
    * into the order_id column on the order_lines table).
    */
   private void makeUnidirectional(DeployBeanPropertyAssocMany<?> oneToMany) {
-    DeployBeanDescriptor<?> targetDesc = getTargetDescriptor(oneToMany);
+    DeployBeanDescriptor<?> targetDesc = targetDescriptor(oneToMany);
     Class<?> owningType = oneToMany.getOwningType();
     if (!oneToMany.getCascadeInfo().isSave()) {
       // The property MUST have persist cascading so that inserts work.
@@ -915,7 +915,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
     oneToMany.setUnidirectional();
 
     // specify table and table alias...
-    BeanTable beanTable = getBeanTable(owningType);
+    BeanTable beanTable = beanTable(owningType);
 
     // define the TableJoin
     DeployTableJoin oneToManyJoin = oneToMany.getTableJoin();
@@ -951,7 +951,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
     // its associated join information if it is available
     String mappedBy = prop.getMappedBy();
     // get the mappedBy property
-    DeployBeanDescriptor<?> targetDesc = getTargetDescriptor(prop);
+    DeployBeanDescriptor<?> targetDesc = targetDescriptor(prop);
     DeployBeanProperty mappedProp = targetDesc.getBeanProperty(mappedBy);
     if (mappedProp == null) {
       String m = "Error on " + prop.getFullBeanName();
@@ -1008,7 +1008,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
       // skip mapping check
       return;
     }
-    DeployBeanDescriptor<?> targetDesc = getTargetDescriptor(prop);
+    DeployBeanDescriptor<?> targetDesc = targetDescriptor(prop);
 
     if (targetDesc.isDraftableElement()) {
       // automatically turning on orphan removal and CascadeType.ALL
@@ -1087,14 +1087,14 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
     // get the bean descriptor that holds the mappedBy property
     String mappedBy = prop.getMappedBy();
     if (mappedBy == null) {
-      if (getTargetDescriptor(prop).isDraftable()) {
+      if (targetDescriptor(prop).isDraftable()) {
         prop.setIntersectionDraftTable();
       }
       return;
     }
 
     // get the mappedBy property
-    DeployBeanDescriptor<?> targetDesc = getTargetDescriptor(prop);
+    DeployBeanDescriptor<?> targetDesc = targetDescriptor(prop);
     DeployBeanProperty mappedProp = targetDesc.getBeanProperty(mappedBy);
 
     if (mappedProp == null) {
@@ -1433,14 +1433,14 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
    * Return the changeLogPrepare (for setting user context into the ChangeSet
    * in the foreground thread).
    */
-  public ChangeLogPrepare getChangeLogPrepare() {
+  public ChangeLogPrepare changeLogPrepare() {
     return changeLogPrepare;
   }
 
   /**
    * Return the changeLogListener (that actually does the logging).
    */
-  public ChangeLogListener getChangeLogListener() {
+  public ChangeLogListener changeLogListener() {
     return changeLogListener;
   }
 
@@ -1517,7 +1517,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
 
     @Override
     public int compare(BeanDescriptor<?> o1, BeanDescriptor<?> o2) {
-      return o1.getName().compareTo(o2.getName());
+      return o1.name().compareTo(o2.name());
     }
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorMap.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorMap.java
index 94a9fded9..e5ba63521 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorMap.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorMap.java
@@ -20,22 +20,22 @@ public interface BeanDescriptorMap {
   /**
    * Return the name of the server/database.
    */
-  String getServerName();
+  String name();
 
   /**
    * Return the DatabaseConfig.
    */
-  DatabaseConfig getConfig();
+  DatabaseConfig config();
 
   /**
    * Return the Cache Manager.
    */
-  SpiCacheManager getCacheManager();
+  SpiCacheManager cacheManager();
 
   /**
    * Return the naming convention.
    */
-  NamingConvention getNamingConvention();
+  NamingConvention namingConvention();
 
   /**
    * Return true if multiple values can be bound as Array or Table Value and hence share the same query plan.
@@ -45,12 +45,12 @@ public interface BeanDescriptorMap {
   /**
    * Return the BeanDescriptor for a given class.
    */
-  <T> BeanDescriptor<T> getBeanDescriptor(Class<T> entityType);
+  <T> BeanDescriptor<T> descriptor(Class<T> entityType);
 
   /**
    * Return the Encrypt key given the table and column name.
    */
-  EncryptKey getEncryptKey(String tableName, String columnName);
+  EncryptKey encryptKey(String tableName, String columnName);
 
   /**
    * Create a IdBinder for this bean property.
@@ -65,18 +65,18 @@ public interface BeanDescriptorMap {
   /**
    * Return the scalarType for the given JDBC type.
    */
-  ScalarType<?> getScalarType(int jdbcType);
+  ScalarType<?> scalarType(int jdbcType);
 
   /**
    * Return the scalarType for the given logical type.
    */
-  ScalarType<?> getScalarType(String cast);
+  ScalarType<?> scalarType(String cast);
 
   /**
    * Return true if Jackson core is present on the classpath.
    */
   boolean isJacksonCorePresent();
-  
+
   /**
    * Returns true, if the given table (or view) is managed by ebean
    * (= an entity exists)
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanEmbeddedMetaFactory.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanEmbeddedMetaFactory.java
index d6ee56491..d5c303dcb 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanEmbeddedMetaFactory.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanEmbeddedMetaFactory.java
@@ -19,7 +19,7 @@ final class BeanEmbeddedMetaFactory {
     // we can get a BeanDescriptor for an Embedded bean
     // and know that it is NOT recursive, as Embedded beans are
     // only allow to hold simple scalar types...
-    BeanDescriptor<?> targetDesc = owner.getBeanDescriptor(prop.getTargetType());
+    BeanDescriptor<?> targetDesc = owner.descriptor(prop.getTargetType());
     if (targetDesc == null) {
       String msg = "Could not find BeanDescriptor for " + prop.getTargetType()
         + ". Perhaps the EmbeddedId class is not registered? See https://ebean.io/docs/trouble-shooting#not-registered";
@@ -34,7 +34,7 @@ final class BeanEmbeddedMetaFactory {
     BeanProperty[] embeddedProperties = new BeanProperty[sourceProperties.length];
 
     for (int i = 0; i < sourceProperties.length; i++) {
-      String propertyName = sourceProperties[i].getName();
+      String propertyName = sourceProperties[i].name();
       Column column = propColMap.get(propertyName);
       String dbColumn = dbColumn(columnPrefix, column, sourceProperties[i]);
       boolean dbNullable = dbNullable(column, sourceProperties[i]);
@@ -49,7 +49,7 @@ final class BeanEmbeddedMetaFactory {
   }
 
   private static String dbColumn(String prefix, Column override, BeanProperty source) {
-    String dbCol = (override != null && !override.name().isEmpty()) ? override.name() : source.getDbColumn();
+    String dbCol = (override != null && !override.name().isEmpty()) ? override.name() : source.dbColumn();
     return prefix == null ? dbCol : prefix + dbCol;
   }
 
@@ -58,15 +58,15 @@ final class BeanEmbeddedMetaFactory {
   }
 
   private static int dbLength(Column override, BeanProperty source) {
-    return (override != null && (override.length() != 255)) ? override.length() : source.getDbLength();
+    return (override != null && (override.length() != 255)) ? override.length() : source.dbLength();
   }
 
   private static int dbScale(Column override, BeanProperty source) {
-    return (override != null && (override.scale() != 0)) ? override.scale() : source.getDbScale();
+    return (override != null && (override.scale() != 0)) ? override.scale() : source.dbScale();
   }
 
   private static String getDbColumnDefn(Column override, BeanProperty source) {
-    return (override != null && !override.columnDefinition().isEmpty()) ? override.columnDefinition() : source.getDbColumnDefn();
+    return (override != null && !override.columnDefinition().isEmpty()) ? override.columnDefinition() : source.dbColumnDefn();
   }
 
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanFkeyProperty.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanFkeyProperty.java
index 071a0f660..bd479b08d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanFkeyProperty.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanFkeyProperty.java
@@ -42,7 +42,7 @@ public final class BeanFkeyProperty implements ElPropertyValue {
   }
 
   @Override
-  public int getFetchPreference() {
+  public int fetchPreference() {
     // return some decently high value
     return 1000;
   }
@@ -101,17 +101,17 @@ public final class BeanFkeyProperty implements ElPropertyValue {
   }
 
   @Override
-  public String getDbColumn() {
+  public String dbColumn() {
     return dbColumn;
   }
 
   @Override
-  public String getName() {
+  public String name() {
     return name;
   }
 
   @Override
-  public String getElName() {
+  public String elName() {
     return name;
   }
 
@@ -119,7 +119,7 @@ public final class BeanFkeyProperty implements ElPropertyValue {
    * Returns null as not an AssocOne.
    */
   @Override
-  public Object[] getAssocIdValues(EntityBean value) {
+  public Object[] assocIdValues(EntityBean value) {
     return null;
   }
 
@@ -127,7 +127,7 @@ public final class BeanFkeyProperty implements ElPropertyValue {
    * Returns null as not an AssocOne.
    */
   @Override
-  public String getAssocIdExpression(String prefix, String operator) {
+  public String assocIdExpression(String prefix, String operator) {
     return null;
   }
 
@@ -135,7 +135,7 @@ public final class BeanFkeyProperty implements ElPropertyValue {
    * Returns null as not an AssocOne.
    */
   @Override
-  public String getAssocIdInExpr(String prefix) {
+  public String assocIdInExpr(String prefix) {
     return null;
   }
 
@@ -143,12 +143,12 @@ public final class BeanFkeyProperty implements ElPropertyValue {
    * Returns null as not an AssocOne.
    */
   @Override
-  public String getAssocIdInValueExpr(boolean not, int size) {
+  public String assocIdInValueExpr(boolean not, int size) {
     return null;
   }
 
   @Override
-  public String getAssocIsEmpty(SpiExpressionRequest request, String path) {
+  public String assocIsEmpty(SpiExpressionRequest request, String path) {
     throw new RuntimeException("Not Supported or Expected");
   }
 
@@ -171,12 +171,12 @@ public final class BeanFkeyProperty implements ElPropertyValue {
   }
 
   @Override
-  public String getElPlaceholder(boolean encrypted) {
+  public String elPlaceholder(boolean encrypted) {
     return placeHolder;
   }
 
   @Override
-  public String getElPrefix() {
+  public String elPrefix() {
     return prefix;
   }
 
@@ -186,12 +186,12 @@ public final class BeanFkeyProperty implements ElPropertyValue {
   }
 
   @Override
-  public int getJdbcType() {
+  public int jdbcType() {
     return 0;
   }
 
   @Override
-  public BeanProperty getBeanProperty() {
+  public BeanProperty beanProperty() {
     return null;
   }
 
@@ -201,7 +201,7 @@ public final class BeanFkeyProperty implements ElPropertyValue {
   }
 
   @Override
-  public StringParser getStringParser() {
+  public StringParser stringParser() {
     throw new RuntimeException("ElPropertyDeploy only - not implemented");
   }
 
@@ -226,7 +226,7 @@ public final class BeanFkeyProperty implements ElPropertyValue {
   }
 
   @Override
-  public Property getProperty() {
+  public Property property() {
     throw new RuntimeException("ElPropertyDeploy only - not implemented");
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanLifecycleAdapterFactory.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanLifecycleAdapterFactory.java
index f754c9060..e9d9c5372 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanLifecycleAdapterFactory.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanLifecycleAdapterFactory.java
@@ -208,7 +208,7 @@ final class BeanLifecycleAdapterFactory {
 
     private void invoke(Method[] methods, BeanPersistRequest<?> request) {
       for (Method method : methods) {
-        invoke(method, request.getBean());
+        invoke(method, request.bean());
       }
     }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanListHelp.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanListHelp.java
index 64cd91494..5696e9b19 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanListHelp.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanListHelp.java
@@ -50,7 +50,7 @@ public class BeanListHelp<T> extends BaseCollectionHelp<T> {
   public BeanCollection<T> createEmpty(EntityBean parentBean) {
     BeanList<T> beanList = new BeanList<>(loader, parentBean, propertyName);
     if (many != null) {
-      beanList.setModifyListening(many.getModifyListenMode());
+      beanList.setModifyListening(many.modifyListenMode());
     }
     return beanList;
   }
@@ -59,7 +59,7 @@ public class BeanListHelp<T> extends BaseCollectionHelp<T> {
   public BeanCollection<T> createReference(EntityBean parentBean) {
 
     BeanList<T> beanList = new BeanList<>(loader, parentBean, propertyName);
-    beanList.setModifyListening(many.getModifyListenMode());
+    beanList.setModifyListening(many.modifyListenMode());
     return beanList;
   }
 
@@ -77,7 +77,7 @@ public class BeanListHelp<T> extends BaseCollectionHelp<T> {
 
     List<?> currentList = (List<?>) many.getValue(parentBean);
 
-    newBeanList.setModifyListening(many.getModifyListenMode());
+    newBeanList.setModifyListening(many.modifyListenMode());
 
     if (currentList == null) {
       // the currentList is null? Not really expecting this...
@@ -87,7 +87,7 @@ public class BeanListHelp<T> extends BaseCollectionHelp<T> {
       // normally this case, replace just the underlying list
       BeanList<?> currentBeanList = (BeanList<?>) currentList;
       currentBeanList.setActualList(newBeanList.getActualList());
-      currentBeanList.setModifyListening(many.getModifyListenMode());
+      currentBeanList.setModifyListening(many.modifyListenMode());
 
     } else {
       // replace the entire list with the BeanList
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanMapHelp.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanMapHelp.java
index 9a6812d97..d2cec7d13 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanMapHelp.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanMapHelp.java
@@ -29,9 +29,9 @@ public class BeanMapHelp<T> extends BaseCollectionHelp<T> {
    */
   BeanMapHelp(BeanPropertyAssocMany<T> many) {
     this.many = many;
-    this.targetDescriptor = many.getTargetDescriptor();
-    this.propertyName = many.getName();
-    this.beanProperty = targetDescriptor.getBeanProperty(many.getMapKey());
+    this.targetDescriptor = many.targetDescriptor();
+    this.propertyName = many.name();
+    this.beanProperty = targetDescriptor.beanProperty(many.mapKey());
   }
 
   @Override
@@ -39,9 +39,9 @@ public class BeanMapHelp<T> extends BaseCollectionHelp<T> {
   public BeanCollectionAdd getBeanCollectionAdd(Object bc, String mapKey) {
 
     if (mapKey == null) {
-      mapKey = many.getMapKey();
+      mapKey = many.mapKey();
     }
-    BeanProperty beanProp = targetDescriptor.getBeanProperty(mapKey);
+    BeanProperty beanProp = targetDescriptor.beanProperty(mapKey);
 
     if (bc instanceof BeanMap<?, ?>) {
       BeanMap<Object, Object> bm = (BeanMap<Object, Object>) bc;
@@ -85,7 +85,7 @@ public class BeanMapHelp<T> extends BaseCollectionHelp<T> {
 
     BeanMap<?, T> beanMap = new BeanMap<>(loader, ownerBean, propertyName);
     if (many != null) {
-      beanMap.setModifyListening(many.getModifyListenMode());
+      beanMap.setModifyListening(many.modifyListenMode());
     }
     return beanMap;
   }
@@ -108,7 +108,7 @@ public class BeanMapHelp<T> extends BaseCollectionHelp<T> {
 
     BeanMap beanMap = new BeanMap(loader, parentBean, propertyName);
     if (many != null) {
-      beanMap.setModifyListening(many.getModifyListenMode());
+      beanMap.setModifyListening(many.modifyListenMode());
     }
     return beanMap;
   }
@@ -125,7 +125,7 @@ public class BeanMapHelp<T> extends BaseCollectionHelp<T> {
     BeanMap<?, ?> newBeanMap = (BeanMap<?, ?>) bc;
     Map<?, ?> current = (Map<?, ?>) many.getValue(parentBean);
 
-    newBeanMap.setModifyListening(many.getModifyListenMode());
+    newBeanMap.setModifyListening(many.modifyListenMode());
     if (current == null) {
       // the currentMap is null? Not really expecting this...
       many.setValue(parentBean, newBeanMap);
@@ -134,7 +134,7 @@ public class BeanMapHelp<T> extends BaseCollectionHelp<T> {
       // normally this case, replace just the underlying list
       BeanMap<?, ?> currentBeanMap = (BeanMap<?, ?>) current;
       currentBeanMap.setActualMap(newBeanMap.getActualMap());
-      currentBeanMap.setModifyListening(many.getModifyListenMode());
+      currentBeanMap.setModifyListening(many.modifyListenMode());
 
     } else {
       // replace the entire set
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanProperty.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanProperty.java
index 74e75702a..31fe858ce 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanProperty.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanProperty.java
@@ -14,7 +14,6 @@ import io.ebean.core.type.DocPropertyType;
 import io.ebean.core.type.ScalarType;
 import io.ebean.plugin.Property;
 import io.ebean.text.StringParser;
-import io.ebean.text.TextException;
 import io.ebean.util.SplitName;
 import io.ebeaninternal.api.SpiExpressionRequest;
 import io.ebeaninternal.api.SpiQuery;
@@ -50,7 +49,6 @@ import java.io.IOException;
 import java.lang.reflect.Field;
 import java.sql.SQLException;
 import java.sql.Types;
-import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -269,7 +267,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
       s = s.replace("${ta}", "${}");
       if (dbEncrypted) {
         s = dbEncryptFunction.getDecryptSql(s);
-        String namedParam = ":encryptkey_" + descriptor.getBaseTable() + "___" + dbColumn;
+        String namedParam = ":encryptkey_" + descriptor.baseTable() + "___" + dbColumn;
         s = s.replace("?", namedParam);
       }
     }
@@ -286,7 +284,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   protected BeanProperty(BeanProperty source, BeanPropertyOverride override) {
     this.descriptor = source.descriptor;
     this.propertyIndex = source.propertyIndex;
-    this.name = source.getName();
+    this.name = source.name();
     this.dbColumn = override.getDbColumn();
     this.nullable = override.isDbNullable();
     this.dbLength = override.getDbLength();
@@ -316,9 +314,9 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
     this.secondaryTableJoin = source.secondaryTableJoin;
     this.secondaryTableJoinPrefix = source.secondaryTableJoinPrefix;
     this.dbComment = source.dbComment;
-    this.dbBind = source.getDbBind();
+    this.dbBind = source.dbBind();
     this.dbEncrypted = source.isDbEncrypted();
-    this.dbEncryptedType = source.getDbEncryptedType();
+    this.dbEncryptedType = source.dbEncryptedType();
     this.dbEncryptFunction = source.dbEncryptFunction;
     this.dbRead = source.isDbRead();
     this.dbInsertable = source.isDbInsertable();
@@ -329,18 +327,18 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
     this.dbMigrationInfos = source.dbMigrationInfos;
     this.inherited = source.isInherited();
     this.owningType = source.owningType;
-    this.local = owningType.equals(descriptor.getBeanType());
+    this.local = owningType.equals(descriptor.type());
     this.version = source.isVersion();
     this.embedded = source.isEmbedded();
     this.id = source.isId();
-    this.generatedProperty = source.getGeneratedProperty();
+    this.generatedProperty = source.generatedProperty();
     this.getter = source.getter;
     this.setter = source.setter;
-    this.dbType = source.getDbType(true);
+    this.dbType = source.dbType(true);
     this.scalarType = source.scalarType;
     this.lob = isLobType(dbType);
-    this.propertyType = source.getPropertyType();
-    this.field = source.getField();
+    this.propertyType = source.type();
+    this.field = source.field();
     this.docOptions = source.docOptions;
     this.unmappedJson = source.unmappedJson;
     this.elPrefix = override.replace(source.elPrefix, source.dbColumn);
@@ -358,14 +356,14 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   public void initialise(BeanDescriptorInitContext initContext) {
     // do nothing for normal BeanProperty
     if (!isTransient && scalarType == null) {
-      throw new RuntimeException("No ScalarType assigned to " + descriptor.getFullName() + "." + getName());
+      throw new RuntimeException("No ScalarType assigned to " + descriptor.fullName() + "." + name());
     }
   }
 
   /**
    * Return the order this property appears in the bean.
    */
-  public int getDeployOrder() {
+  public int deployOrder() {
     return deployOrder;
   }
 
@@ -383,7 +381,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   /**
    * Return the BeanDescriptor that owns this property.
    */
-  public BeanDescriptor<?> getBeanDescriptor() {
+  public BeanDescriptor<?> descriptor() {
     return descriptor;
   }
 
@@ -426,28 +424,28 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   /**
    * Return the encrypt key for the column matching this property.
    */
-  public EncryptKey getEncryptKey() {
-    return descriptor.getEncryptKey(this);
+  public EncryptKey encryptKey() {
+    return descriptor.encryptKey(this);
   }
 
   @Override
-  public String getEncryptKeyAsString() {
-    return getEncryptKey().getStringValue();
+  public String encryptKeyAsString() {
+    return encryptKey().getStringValue();
   }
 
-  public String getDecryptProperty(String propertyName) {
+  public String decryptProperty(String propertyName) {
     return dbEncryptFunction.getDecryptSql(propertyName);
   }
 
   /**
    * Return the SQL for the column including decryption function and column alias.
    */
-  private String getDecryptSqlWithColumnAlias(String tableAlias) {
-    return dbEncryptFunction.getDecryptSql(tableAlias + "." + this.getDbColumn()) + ENC_PREFIX + tableAlias + "_" + this.getDbColumn();
+  private String decryptSqlWithColumnAlias(String tableAlias) {
+    return dbEncryptFunction.getDecryptSql(tableAlias + "." + this.dbColumn()) + ENC_PREFIX + tableAlias + "_" + this.dbColumn();
   }
 
   @Override
-  public int getFetchPreference() {
+  public int fetchPreference() {
     // return some decently high value - override on ToMany property
     return 1000;
   }
@@ -470,7 +468,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
    * Returns null unless this property is using a secondary table. In that
    * case this returns the logical property prefix.
    */
-  public String getSecondaryTableJoinPrefix() {
+  public String secondaryTableJoinPrefix() {
     return secondaryTableJoinPrefix;
   }
 
@@ -490,7 +488,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
         ctx.pushTableAlias(ctx.getRelativePrefix(secondaryTableJoinPrefix));
       }
       if (dbEncrypted) {
-        ctx.appendRawColumn(getDecryptSqlWithColumnAlias(ctx.peekTableAlias()));
+        ctx.appendRawColumn(decryptSqlWithColumnAlias(ctx.peekTableAlias()));
         ctx.addEncryptedProp(this);
       } else {
         ctx.appendColumn(dbColumn);
@@ -569,12 +567,12 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   }
 
   @Override
-  public BeanProperty getBeanProperty() {
+  public BeanProperty beanProperty() {
     return this;
   }
 
   @Override
-  public Property getProperty() {
+  public Property property() {
     return this;
   }
 
@@ -606,14 +604,14 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   /**
    * Return the DB literal expression to set the deleted state to true.
    */
-  String getSoftDeleteDbSet() {
+  String softDeleteDbSet() {
     return softDeleteDbSet;
   }
 
   /**
    * Return the DB literal predicate used to filter out soft deleted rows from a query.
    */
-  String getSoftDeleteDbPredicate(String tableAlias) {
+  String softDeleteDbPredicate(String tableAlias) {
     return tableAlias + softDeleteDbPredicate;
   }
 
@@ -758,7 +756,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   }
 
   @Override
-  public Object getVal(Object bean) {
+  public Object value(Object bean) {
     return getValue((EntityBean) bean);
   }
 
@@ -819,19 +817,19 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
    */
   @Override
   @Nonnull
-  public String getName() {
+  public String name() {
     return name;
   }
 
   /**
    * Return the position of this property in the enhanced bean.
    */
-  public int getPropertyIndex() {
+  public int propertyIndex() {
     return propertyIndex;
   }
 
   @Override
-  public String getElName() {
+  public String elName() {
     return name;
   }
 
@@ -851,31 +849,31 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   }
 
   @Override
-  public String getAssocIsEmpty(SpiExpressionRequest request, String path) {
+  public String assocIsEmpty(SpiExpressionRequest request, String path) {
     // overridden in BanePropertyAssocMany
     throw new RuntimeException("Not Supported or Expected");
   }
 
   @Override
-  public Object[] getAssocIdValues(EntityBean bean) {
+  public Object[] assocIdValues(EntityBean bean) {
     // Returns null as not an AssocOne.
     return null;
   }
 
   @Override
-  public String getAssocIdExpression(String prefix, String operator) {
+  public String assocIdExpression(String prefix, String operator) {
     // Returns null as not an AssocOne.
     return null;
   }
 
   @Override
-  public String getAssocIdInExpr(String prefix) {
+  public String assocIdInExpr(String prefix) {
     // Returns null as not an AssocOne.
     return null;
   }
 
   @Override
-  public String getAssocIdInValueExpr(boolean not, int size) {
+  public String assocIdInValueExpr(boolean not, int size) {
     // Returns null as not an AssocOne.
     return null;
   }
@@ -906,12 +904,12 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   }
 
   @Override
-  public String getElPlaceholder(boolean encrypted) {
+  public String elPlaceholder(boolean encrypted) {
     return encrypted ? elPlaceHolderEncrypted : elPlaceHolder;
   }
 
   @Override
-  public String getElPrefix() {
+  public String elPrefix() {
     return elPrefix;
   }
 
@@ -919,8 +917,8 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
    * Return the full name of this property.
    */
   @Override
-  public String getFullBeanName() {
-    return descriptor.getFullName() + "." + name;
+  public String fullName() {
+    return descriptor.fullName() + "." + name;
   }
 
   /**
@@ -936,12 +934,12 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
    */
   @Override
   @SuppressWarnings(value = "unchecked")
-  public ScalarType<Object> getScalarType() {
+  public ScalarType<Object> scalarType() {
     return scalarType;
   }
 
   @Override
-  public StringParser getStringParser() {
+  public StringParser stringParser() {
     return scalarType;
   }
 
@@ -951,7 +949,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   }
 
   @Override
-  public int getJdbcType() {
+  public int jdbcType() {
     return scalarType == null ? 0 : scalarType.getJdbcType();
   }
 
@@ -963,21 +961,21 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   /**
    * Return the DB max length (varchar) or precision (decimal).
    */
-  public int getDbLength() {
+  public int dbLength() {
     return dbLength;
   }
 
   /**
    * Return the DB scale for numeric columns.
    */
-  public int getDbScale() {
+  public int dbScale() {
     return dbScale;
   }
 
   /**
    * Return a specific column DDL definition if specified (otherwise null).
    */
-  public String getDbColumnDefn() {
+  public String dbColumnDefn() {
     return dbColumnDefn;
   }
 
@@ -987,7 +985,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
    * For an Enum returns IN expression for the set of Enum values.
    * </p>
    */
-  public Set<String> getDbCheckConstraintValues() {
+  public Set<String> dbCheckConstraintValues() {
     if (scalarType instanceof ScalarTypeEnum) {
       return ((ScalarTypeEnum<?>) scalarType).getDbCheckConstraintValues();
     }
@@ -1007,28 +1005,28 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
   /**
    * Return the DB column default to use for DDL.
    */
-  public String getDbColumnDefault() {
+  public String dbColumnDefault() {
     return dbColumnDefn != null ? null : dbColumnDefault;
   }
 
   /**
    * Return the DDL-Migration Infos
    */
-  public List<DbMigrationInfo> getDbMigrationInfos() {
+  public List<DbMigrationInfo> dbMigrationInfos() {
     return dbMigrationInfos;
   }
 
   /**
    * Return the bean Field associated with this property.
    */
-  private Field getField() {
+  private Field field() {
     return field;
   }
 
   /**
    * Return the GeneratedValue. Used to generate update timestamp etc.
    */
-  public GeneratedProperty getGeneratedProperty() {
+  public GeneratedProperty generatedProperty() {
     return generatedProperty;
   }
 
@@ -1119,14 +1117,14 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
    * The database column name this is mapped to.
    */
   @Override
-  public String getDbColumn() {
+  public String dbColumn() {
     return dbColumn;
   }
 
   /**
    * Return the comment for the associated DB column.
    */
-  public String getDbComment() {
+  public String dbComment() {
     return dbComment;
   }
 
@@ -1135,7 +1133,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
    *
    * @param platformTypes Set as false when we want logical platform agnostic types.
    */
-  public int getDbType(boolean platformTypes) {
+  public int dbType(boolean platformTypes) {
     if (platformTypes || !(scalarType instanceof ScalarTypeLogicalType)) {
       return dbType;
     }
@@ -1184,7 +1182,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
    * Return the DB bind parameter. Typically is "?" but different for
    * encrypted bind.
    */
-  public String getDbBind() {
+  public String dbBind() {
     return dbBind;
   }
 
@@ -1209,7 +1207,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
     return dbEncrypted;
   }
 
-  public int getDbEncryptedType() {
+  public int dbEncryptedType() {
     return dbEncryptedType;
   }
 
@@ -1305,7 +1303,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
    */
   @Override
   @Nonnull
-  public Class<?> getPropertyType() {
+  public Class<?> type() {
     return propertyType;
   }
 
@@ -1413,7 +1411,7 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
           // change in behavior for #318
           objValue = null;
           String msg = "Error trying to use Jackson ObjectMapper to read transient property "
-            + getFullBeanName() + " - consider marking this property with @JsonIgnore";
+            + fullName() + " - consider marking this property with @JsonIgnore";
           logger.error(msg, e);
         }
       }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssoc.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssoc.java
index 33304f5f9..a00942e03 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssoc.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssoc.java
@@ -117,10 +117,10 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
   }
 
   void initialiseTargetDescriptor(BeanDescriptorInitContext initContext) {
-    targetDescriptor = descriptor.getBeanDescriptor(targetType);
+    targetDescriptor = descriptor.descriptor(targetType);
     if (!isTransient) {
-      targetIdBinder = targetDescriptor.getIdBinder();
-      targetInheritInfo = targetDescriptor.getInheritInfo();
+      targetIdBinder = targetDescriptor.idBinder();
+      targetInheritInfo = targetDescriptor.inheritInfo();
       saveRecurseSkippable = targetDescriptor.isSaveRecurseSkippable();
       if (!targetIdBinder.isComplexId()) {
         targetIdProperty = targetIdBinder.getIdProperty();
@@ -129,14 +129,14 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
   }
 
   @Override
-  public int getFetchPreference() {
+  public int fetchPreference() {
     return fetchPreference;
   }
 
   /**
    * Return the extra configuration for the foreign key.
    */
-  public PropertyForeignKey getForeignKey() {
+  public PropertyForeignKey foreignKey() {
     return foreignKey;
   }
 
@@ -159,7 +159,7 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
    */
   ElPropertyValue createElPropertyValue(String propName, String remainder, ElPropertyChainBuilder chain, boolean propertyDeploy) {
     // associated or embedded bean
-    BeanDescriptor<?> embDesc = getTargetDescriptor();
+    BeanDescriptor<?> embDesc = targetDescriptor();
     if (chain == null) {
       chain = new ElPropertyChainBuilder(isEmbedded(), propName);
     }
@@ -198,7 +198,7 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
    * Return the mappedBy property.
    * This will be null on the owning side.
    */
-  public String getMappedBy() {
+  public String mappedBy() {
     return mappedBy;
   }
 
@@ -208,19 +208,19 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
    * This will return null for multiple Id properties.
    * </p>
    */
-  public String getTargetIdProperty() {
+  public String targetIdProperty() {
     return targetIdProperty;
   }
 
   /**
    * Return the BeanDescriptor of the target.
    */
-  public BeanDescriptor<T> getTargetDescriptor() {
+  public BeanDescriptor<T> targetDescriptor() {
     return targetDescriptor;
   }
 
   SpiEbeanServer server() {
-    return descriptor.getEbeanServer();
+    return descriptor.ebeanServer();
   }
 
   /**
@@ -229,12 +229,12 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
    * We use target descriptor rather than target property type to support ElementCollection.
    */
   public SpiQuery<T> newQuery(SpiEbeanServer server) {
-    return new DefaultOrmQuery<>(targetDescriptor, server, server.getExpressionFactory());
+    return new DefaultOrmQuery<>(targetDescriptor, server, server.expressionFactory());
   }
 
   @Override
-  public IdBinder getIdBinder() {
-    return descriptor.getIdBinder();
+  public IdBinder idBinder() {
+    return descriptor.idBinder();
   }
 
   @Override
@@ -251,8 +251,8 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
   }
 
   @Override
-  public String getSoftDeletePredicate(String tableAlias) {
-    return targetDescriptor.getSoftDeletePredicate(tableAlias);
+  public String softDeletePredicate(String tableAlias) {
+    return targetDescriptor.softDeletePredicate(tableAlias);
   }
 
   /**
@@ -283,8 +283,8 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
    * Return true if the unique id properties are all not null for this bean.
    */
   public boolean hasId(EntityBean bean) {
-    BeanDescriptor<?> targetDesc = getTargetDescriptor();
-    BeanProperty idProp = targetDesc.getIdProperty();
+    BeanDescriptor<?> targetDesc = targetDescriptor();
+    BeanProperty idProp = targetDesc.idProperty();
     // all the unique properties are non-null
     return idProp == null || idProp.getValue(bean) != null;
   }
@@ -296,7 +296,7 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
    * set or map.
    * </p>
    */
-  public Class<?> getTargetType() {
+  public Class<?> targetType() {
     return targetType;
   }
 
@@ -305,14 +305,14 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
    * to this bean type.
    */
   @Override
-  public String getExtraWhere() {
+  public String extraWhere() {
     return extraWhere;
   }
 
   /**
    * Return the elastic search doc for this embedded property.
    */
-  private String getDocStoreDoc() {
+  private String docStoreDoc() {
     return docStoreDoc;
   }
 
@@ -321,7 +321,7 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
    */
   @Override
   public void docStoreInclude(boolean includeByDefault, DocStructure docStructure) {
-    String embeddedDoc = getDocStoreDoc();
+    String embeddedDoc = docStoreDoc();
     if (embeddedDoc == null) {
       // not annotated so use include by default
       // which is *ToOne included and *ToMany excluded
@@ -399,21 +399,21 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
   /**
    * Return the underlying BeanTable for this property.
    */
-  public BeanTable getBeanTable() {
+  public BeanTable beanTable() {
     return beanTable;
   }
 
   /**
    * return the join to use for the bean.
    */
-  public TableJoin getTableJoin() {
+  public TableJoin tableJoin() {
     return tableJoin;
   }
 
   /**
    * Get the persist info.
    */
-  public BeanCascadeInfo getCascadeInfo() {
+  public BeanCascadeInfo cascadeInfo() {
     return cascadeInfo;
   }
 
@@ -422,10 +422,10 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
    * descriptor back to local database columns in the TableJoin.
    */
   ImportedId createImportedId(BeanPropertyAssoc<?> owner, BeanDescriptor<?> target, TableJoin join) {
-    BeanProperty idProp = target.getIdProperty();
+    BeanProperty idProp = target.idProperty();
     BeanProperty[] others = target.propertiesBaseScalar();
     if (descriptor.isRawSqlBased()) {
-      String dbColumn = owner.getDbColumn();
+      String dbColumn = owner.dbColumn();
       return new ImportedIdSimple(owner, dbColumn, null, idProp, 0);
     }
     if (idProp == null) {
@@ -445,7 +445,7 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
     } else {
       // embedded id
       BeanPropertyAssocOne<?> embProp = (BeanPropertyAssocOne<?>) idProp;
-      BeanProperty[] embBaseProps = embProp.getTargetDescriptor().propertiesBaseScalar();
+      BeanProperty[] embBaseProps = embProp.targetDescriptor().propertiesBaseScalar();
       ImportedIdSimple[] scalars = createImportedList(owner, cols, embBaseProps, others);
       return new ImportedIdEmbedded(owner, embProp, scalars);
     }
@@ -466,16 +466,16 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
     boolean insertable = col.isInsertable();
     boolean updateable = col.isUpdateable();
     for (int j = 0; j < props.length; j++) {
-      if (props[j].getDbColumn().equalsIgnoreCase(matchColumn)) {
+      if (props[j].dbColumn().equalsIgnoreCase(matchColumn)) {
         return new ImportedIdSimple(owner, localColumn, localSqlFormula, props[j], j, insertable, updateable);
       }
     }
     for (int j = 0; j < others.length; j++) {
-      if (others[j].getDbColumn().equalsIgnoreCase(matchColumn)) {
+      if (others[j].dbColumn().equalsIgnoreCase(matchColumn)) {
         return new ImportedIdSimple(owner, localColumn, localSqlFormula, others[j], j + props.length, insertable, updateable);
       }
     }
-    String msg = "Error with the Join on [" + getFullBeanName()
+    String msg = "Error with the Join on [" + fullName()
       + "]. Could not find the local match for [" + matchColumn + "] "//in table["+searchTable+"]?"
       + " Perhaps an error in a @JoinColumn";
     throw new PersistenceException(msg);
@@ -566,7 +566,7 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
       }
     }
 
-    String msg = "Error with the Join on [" + getFullBeanName()
+    String msg = "Error with the Join on [" + fullName()
       + "]. Could not find the matching foreign key for [" + matchColumn + "] in table[" + searchTable + "]?"
       + " Perhaps using a @JoinColumn with the name/referencedColumnName attributes swapped? "
       + " or a @JoinColumn needs an explicit referencedColumnName specified?";
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocMany.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocMany.java
index 37e5b7990..761309045 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocMany.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocMany.java
@@ -175,9 +175,9 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
    */
   void initialisePostTarget() {
     if (childMasterProperty != null) {
-      BeanProperty masterId = childMasterProperty.getTargetDescriptor().getIdProperty();
+      BeanProperty masterId = childMasterProperty.targetDescriptor().idProperty();
       if (masterId != null) { // in docstore only, the master-id may be not available
-        childMasterIdProperty = childMasterProperty.getName() + "." + masterId.getName();
+        childMasterIdProperty = childMasterProperty.name() + "." + masterId.name();
       }
     }
   }
@@ -200,7 +200,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
   @Override
   public void registerColumn(BeanDescriptor<?> desc, String prefix) {
     if (targetDescriptor != null) {
-      desc.registerTable(targetDescriptor.getBaseTable(), this);
+      desc.registerTable(targetDescriptor.baseTable(), this);
     }
   }
 
@@ -208,8 +208,8 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
    * Return the underlying collection of beans.
    */
   @SuppressWarnings("rawtypes")
-  public Collection getRawCollection(EntityBean bean) {
-    return help.underlying(getVal(bean));
+  public Collection rawCollection(EntityBean bean) {
+    return help.underlying(value(bean));
   }
 
   /**
@@ -217,11 +217,11 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
    */
   @Override
   public void merge(EntityBean bean, EntityBean existing) {
-    Object existingCollection = getVal(existing);
+    Object existingCollection = value(existing);
     if (existingCollection instanceof BeanCollection<?>) {
       BeanCollection<?> toBC = (BeanCollection<?>) existingCollection;
       if (!toBC.isPopulated()) {
-        Object fromCollection = getVal(bean);
+        Object fromCollection = value(bean);
         if (fromCollection instanceof BeanCollection<?>) {
           BeanCollection<?> fromBC = (BeanCollection<?>) fromCollection;
           if (fromBC.isPopulated()) {
@@ -375,7 +375,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
   /**
    * Return the mode for listening to modifications to collections for this association.
    */
-  public ModifyListenMode getModifyListenMode() {
+  public ModifyListenMode modifyListenMode() {
     return modifyListenMode;
   }
 
@@ -410,19 +410,19 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
   }
 
   @Override
-  public String getAssocIsEmpty(SpiExpressionRequest request, String path) {
+  public String assocIsEmpty(SpiExpressionRequest request, String path) {
     boolean softDelete = targetDescriptor.isSoftDelete();
-    boolean needsX2Table = softDelete || getExtraWhere() != null;
+    boolean needsX2Table = softDelete || extraWhere() != null;
     StringBuilder sb = new StringBuilder(50);
-    SpiQuery<?> query = request.getQueryRequest().getQuery();
+    SpiQuery<?> query = request.getQueryRequest().query();
     if (hasJoinTable()) {
       sb.append(query.isAsDraft() ? intersectionDraftTable : intersectionPublishTable);
     } else {
-      sb.append(targetDescriptor.getBaseTable(query.getTemporalMode()));
+      sb.append(targetDescriptor.baseTable(query.getTemporalMode()));
     }
     if (needsX2Table && hasJoinTable()) {
       sb.append(" x join ");
-      sb.append(targetDescriptor.getBaseTable(query.getTemporalMode()));
+      sb.append(targetDescriptor.baseTable(query.getTemporalMode()));
       sb.append(" x2 on ");
       inverseJoin.addJoin("x2", "x", sb);
     } else {
@@ -435,17 +435,17 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
       }
       exportedProperties[i].appendWhere(sb, "x.", path);
     }
-    if (getExtraWhere() != null) {
+    if (extraWhere() != null) {
       sb.append(" and ");
       if (hasJoinTable()) {
-        sb.append(getExtraWhere().replace("${ta}", "x2").replace("${mta}", "x"));
+        sb.append(extraWhere().replace("${ta}", "x2").replace("${mta}", "x"));
       } else {
-        sb.append(getExtraWhere().replace("${ta}", "x"));
+        sb.append(extraWhere().replace("${ta}", "x"));
       }
     }
     if (softDelete) {
       String alias = hasJoinTable() ? "x2" : "x";
-      sb.append(" and ").append(targetDescriptor.getSoftDeletePredicate(alias));
+      sb.append(" and ").append(targetDescriptor.softDeletePredicate(alias));
     }
     return sb.toString();
   }
@@ -454,32 +454,32 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
    * Return the Id values from the given bean.
    */
   @Override
-  public Object[] getAssocIdValues(EntityBean bean) {
-    return targetDescriptor.getIdBinder().getIdValues(bean);
+  public Object[] assocIdValues(EntityBean bean) {
+    return targetDescriptor.idBinder().getIdValues(bean);
   }
 
   /**
    * Return the Id expression to add to where clause etc.
    */
   @Override
-  public String getAssocIdExpression(String prefix, String operator) {
-    return targetDescriptor.getIdBinder().getAssocOneIdExpr(prefix, operator);
+  public String assocIdExpression(String prefix, String operator) {
+    return targetDescriptor.idBinder().getAssocOneIdExpr(prefix, operator);
   }
 
   /**
    * Return the logical id value expression taking into account embedded id's.
    */
   @Override
-  public String getAssocIdInValueExpr(boolean not, int size) {
-    return targetDescriptor.getIdBinder().getIdInValueExpr(not, size);
+  public String assocIdInValueExpr(boolean not, int size) {
+    return targetDescriptor.idBinder().getIdInValueExpr(not, size);
   }
 
   /**
    * Return the logical id in expression taking into account embedded id's.
    */
   @Override
-  public String getAssocIdInExpr(String prefix) {
-    return targetDescriptor.getIdBinder().getAssocIdInExpr(prefix);
+  public String assocIdInExpr(String prefix) {
+    return targetDescriptor.idBinder().getAssocIdInExpr(prefix);
   }
 
   @Override
@@ -521,7 +521,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
   /**
    * Return the many type.
    */
-  public ManyType getManyType() {
+  public ManyType manyType() {
     return manyType;
   }
 
@@ -554,7 +554,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
   /**
    * Return the element bean descriptor (for an element collection only).
    */
-  public BeanDescriptor<T> getElementDescriptor() {
+  public BeanDescriptor<T> elementDescriptor() {
     return elementDescriptor;
   }
 
@@ -562,7 +562,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
    * ManyToMany only, join from local table to intersection table.
    */
   @Override
-  public TableJoin getIntersectionTableJoin() {
+  public TableJoin intersectionTableJoin() {
     return intersectionJoin;
   }
 
@@ -585,21 +585,21 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
    * Return the order by clause used to order the fetching of the data for
    * this list, set or map.
    */
-  public String getFetchOrderBy() {
+  public String fetchOrderBy() {
     return fetchOrderBy;
   }
 
   /**
    * Return the order by for use when lazy loading the associated collection.
    */
-  public String getLazyFetchOrderBy() {
+  public String lazyFetchOrderBy() {
     return lazyFetchOrderBy;
   }
 
   /**
    * Return the default mapKey when returning a Map.
    */
-  public String getMapKey() {
+  public String mapKey() {
     return mapKey;
   }
 
@@ -631,11 +631,11 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
     return help.createEmpty(parentBean);
   }
 
-  private BeanCollectionAdd getBeanCollectionAdd(Object bc) {
+  private BeanCollectionAdd beanCollectionAdd(Object bc) {
     return help.getBeanCollectionAdd(bc, null);
   }
 
-  public Object getParentId(EntityBean parentBean) {
+  public Object parentId(EntityBean parentBean) {
     return descriptor.getId(parentBean);
   }
 
@@ -654,12 +654,12 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
    * Create the array of ExportedProperty used to build reference objects.
    */
   private ExportedProperty[] createExported() {
-    BeanProperty idProp = descriptor.getIdProperty();
+    BeanProperty idProp = descriptor.idProperty();
     ArrayList<ExportedProperty> list = new ArrayList<>();
     if (idProp != null && idProp.isEmbedded()) {
       BeanPropertyAssocOne<?> one = (BeanPropertyAssocOne<?>) idProp;
       try {
-        for (BeanProperty emId : one.getTargetDescriptor().propertiesBaseScalar()) {
+        for (BeanProperty emId : one.targetDescriptor().propertiesBaseScalar()) {
           list.add(findMatch(true, emId));
         }
       } catch (PersistenceException e) {
@@ -680,9 +680,9 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
   private ExportedProperty findMatch(boolean embedded, BeanProperty prop) {
     if (hasJoinTable()) {
       // look for column going to intersection
-      return findMatch(embedded, prop, prop.getDbColumn(), intersectionJoin);
+      return findMatch(embedded, prop, prop.dbColumn(), intersectionJoin);
     } else {
-      return findMatch(embedded, prop, prop.getDbColumn(), tableJoin);
+      return findMatch(embedded, prop, prop.dbColumn(), tableJoin);
     }
   }
 
@@ -697,17 +697,17 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
       return null;
     }
     // search for the property, to see if it exists
-    Class<?> beanType = descriptor.getBeanType();
-    BeanDescriptor<?> targetDesc = getTargetDescriptor();
+    Class<?> beanType = descriptor.type();
+    BeanDescriptor<?> targetDesc = targetDescriptor();
     for (BeanPropertyAssocOne<?> prop : targetDesc.propertiesOne()) {
       if (mappedBy != null) {
         // match using mappedBy as property name
-        if (mappedBy.equalsIgnoreCase(prop.getName())) {
+        if (mappedBy.equalsIgnoreCase(prop.name())) {
           return prop;
         }
       } else {
         // assume only one property that matches parent object type
-        if (prop.getTargetType().equals(beanType)) {
+        if (prop.targetType().equals(beanType)) {
           // found it, stop search
           return prop;
         }
@@ -721,21 +721,21 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
    */
   private BeanProperty initMapKeyProperty() {
     // search for the property
-    BeanDescriptor<?> targetDesc = getTargetDescriptor();
+    BeanDescriptor<?> targetDesc = targetDescriptor();
     for (BeanProperty prop : targetDesc.propertiesAll()) {
-      if (mapKey.equalsIgnoreCase(prop.getName())) {
+      if (mapKey.equalsIgnoreCase(prop.name())) {
         return prop;
       }
     }
-    String from = descriptor.getFullName();
-    String to = targetDesc.getFullName();
+    String from = descriptor.fullName();
+    String to = targetDesc.fullName();
     throw new PersistenceException(from + ": Could not find mapKey property [" + mapKey + "] on [" + to + "]");
   }
 
   public IntersectionRow buildManyDeleteChildren(EntityBean parentBean, List<Object> excludeDetailIds) {
     IntersectionRow row = new IntersectionRow(tableJoin.getTable(), targetDescriptor);
     if (excludeDetailIds != null && !excludeDetailIds.isEmpty()) {
-      row.setExcludeIds(excludeDetailIds, getTargetDescriptor());
+      row.setExcludeIds(excludeDetailIds, targetDescriptor());
     }
     buildExport(row, parentBean);
     return row;
@@ -777,7 +777,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
    */
   public void intersectionBind(SqlUpdate sql, EntityBean parentBean, EntityBean other) {
     if (embeddedExportedProperties) {
-      BeanProperty idProp = descriptor.getIdProperty();
+      BeanProperty idProp = descriptor.idProperty();
       parentBean = (EntityBean) idProp.getValue(parentBean);
     }
     for (ExportedProperty exportedProperty : exportedProperties) {
@@ -788,7 +788,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
 
   private void buildExport(IntersectionRow row, EntityBean parentBean) {
     if (embeddedExportedProperties) {
-      BeanProperty idProp = descriptor.getIdProperty();
+      BeanProperty idProp = descriptor.idProperty();
       parentBean = (EntityBean) idProp.getValue(parentBean);
     }
     for (ExportedProperty exportedProperty : exportedProperties) {
@@ -869,7 +869,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
     draftVal.size();
     Collection<T> actualDetails = draftVal.getActualDetails();
     for (T bean : actualDetails) {
-      Object id = targetDescriptor.getId((EntityBean) bean);
+      Object id = targetDescriptor.id(bean);
       T liveBean = liveBeansAsMap.remove(id);
 
       if (isManyToMany()) {
@@ -899,7 +899,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
     Collection<?> liveBeans = liveVal.getActualDetails();
     Map<Object, T> liveMap = new LinkedHashMap<>();
     for (Object liveBean : liveBeans) {
-      Object id = targetDescriptor.getId((EntityBean) liveBean);
+      Object id = targetDescriptor.id(liveBean);
       liveMap.put(id, (T) liveBean);
     }
     return liveMap;
@@ -1016,7 +1016,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
       return elementDescriptor.jsonReadCollection(readJson, parentBean);
     }
     BeanCollection<?> collection = createEmpty(parentBean);
-    BeanCollectionAdd add = getBeanCollectionAdd(collection);
+    BeanCollectionAdd add = beanCollectionAdd(collection);
     do {
       EntityBean detailBean = (EntityBean) targetDescriptor.jsonRead(readJson, name);
       if (detailBean == null) {
@@ -1044,7 +1044,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
    * Returns true, if we must create a m2m join table.
    */
   public boolean createJoinTable() {
-    if (hasJoinTable() && getMappedBy() == null) {
+    if (hasJoinTable() && mappedBy() == null) {
       // only create on other 'owning' side
       return !descriptor.isTableManaged(intersectionJoin.getTable());
     } else {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyJsonHelp.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyJsonHelp.java
index b84889833..f7ff9fe73 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyJsonHelp.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyJsonHelp.java
@@ -27,7 +27,7 @@ class BeanPropertyAssocManyJsonHelp {
    */
   BeanPropertyAssocManyJsonHelp(BeanPropertyAssocMany<?> many) {
     this.many = many;
-    boolean objectMapperPresent = many.getBeanDescriptor().getConfig().getClassLoadConfig().isJacksonObjectMapperPresent();
+    boolean objectMapperPresent = many.descriptor().config().getClassLoadConfig().isJacksonObjectMapperPresent();
     this.jsonTransient = !objectMapperPresent ? null : new BeanPropertyAssocManyJsonTransient();
   }
 
@@ -58,7 +58,7 @@ class BeanPropertyAssocManyJsonHelp {
    */
   private void jsonReadTransientUsingObjectMapper(SpiJsonReader readJson, EntityBean parentBean) throws IOException {
     if (jsonTransient == null) {
-      throw new IllegalStateException("Jackson ObjectMapper is required to read this Transient property " + many.getFullBeanName());
+      throw new IllegalStateException("Jackson ObjectMapper is required to read this Transient property " + many.fullName());
     }
     jsonTransient.jsonReadUsingObjectMapper(many, readJson, parentBean);
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyJsonTransient.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyJsonTransient.java
index cc43cb9e7..32a84d584 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyJsonTransient.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyJsonTransient.java
@@ -21,18 +21,18 @@ class BeanPropertyAssocManyJsonTransient {
    */
   void jsonReadUsingObjectMapper(BeanPropertyAssocMany<?> many, SpiJsonReader readJson, EntityBean parentBean) throws IOException {
     ObjectMapper mapper = readJson.getObjectMapper();
-    ManyType manyType = many.getManyType();
+    ManyType manyType = many.manyType();
 
     Object value;
     if (manyType.isMap()) {
       // read map using Jackson object mapper with unknown key type
       TypeFactory typeFactory = mapper.getTypeFactory();
-      JavaType target = typeFactory.constructType(many.getTargetType());
+      JavaType target = typeFactory.constructType(many.targetType());
       MapType jacksonType = typeFactory.constructMapType(LinkedHashMap.class, TypeFactory.unknownType(), target);
       value = mapper.readValue(readJson.getParser(), jacksonType);
     } else {
       // read list or set using Jackson object mapper
-      CollectionType jacksonType = mapper.getTypeFactory().constructCollectionType(manyType.getCollectionType(), many.getTargetType());
+      CollectionType jacksonType = mapper.getTypeFactory().constructCollectionType(manyType.getCollectionType(), many.targetType());
       value = mapper.readValue(readJson.getParser(), jacksonType);
     }
     many.setValue(parentBean, value);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManySqlHelp.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManySqlHelp.java
index 8a5eade8b..73caed716 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManySqlHelp.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManySqlHelp.java
@@ -26,7 +26,7 @@ class BeanPropertyAssocManySqlHelp<T> {
     this.many = many;
     this.exportedProperties = exportedProperties;
     this.hasJoinTable = many.hasJoinTable();
-    this.descriptor = many.getBeanDescriptor();
+    this.descriptor = many.descriptor();
     this.exportedPropertyBindProto = deriveExportedPropertyBindProto();
 
     String delStmt;
@@ -73,7 +73,7 @@ class BeanPropertyAssocManySqlHelp<T> {
 
     @Override
     public void visitEmbeddedScalar(BeanProperty p, BeanPropertyAssocOne<?> embedded) {
-      sb.append(",").append(p.getDbColumn());
+      sb.append(",").append(p.dbColumn());
       colCount++;
     }
 
@@ -84,7 +84,7 @@ class BeanPropertyAssocManySqlHelp<T> {
 
     @Override
     public void visitScalar(BeanProperty p, boolean allowNonNull) {
-      sb.append(",").append(p.getDbColumn());
+      sb.append(",").append(p.dbColumn());
       colCount++;
     }
 
@@ -118,13 +118,13 @@ class BeanPropertyAssocManySqlHelp<T> {
       query.setM2MIncludeJoin(many.inverseJoin);
     }
     String rawWhere = deriveWhereParentIdSql(true, tableAlias);
-    String expr = descriptor.getParentIdInExpr(parentIds.size(), rawWhere);
+    String expr = descriptor.parentIdInExpr(parentIds.size(), rawWhere);
     many.bindParentIdsIn(expr, parentIds, query);
   }
 
   List<Object> findIdsByParentId(Object parentId, Transaction t, List<Object> excludeDetailIds, boolean hard) {
     String rawWhere = deriveWhereParentIdSql(false, "");
-    SpiEbeanServer server = descriptor.getEbeanServer();
+    SpiEbeanServer server = descriptor.ebeanServer();
     SpiQuery<?> q = many.newQuery(server);
     many.bindParentIdEq(rawWhere, parentId, q);
     if (hard) {
@@ -141,7 +141,7 @@ class BeanPropertyAssocManySqlHelp<T> {
     String inClause = buildInClauseBinding(parentIds.size(), exportedPropertyBindProto);
     String expr = rawWhere + inClause;
 
-    SpiEbeanServer server = descriptor.getEbeanServer();
+    SpiEbeanServer server = descriptor.ebeanServer();
     SpiQuery<?> q = many.newQuery(server);
     //Query<?> q = server.find(propertyType);
     many.bindParentIdsIn(expr, parentIds, q);
@@ -209,7 +209,7 @@ class BeanPropertyAssocManySqlHelp<T> {
 
   private String buildInClauseBinding(int size, String bindProto) {
     if (descriptor.isSimpleId()) {
-      return descriptor.getIdBinder().getIdInValueExpr(false, size);
+      return descriptor.idBinder().getIdInValueExpr(false, size);
     }
     StringBuilder sb = new StringBuilder(10 + (size * (bindProto.length() + 1)));
     sb.append(" in");
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocOne.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocOne.java
index 3b3c5946c..f8f1c73c7 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocOne.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocOne.java
@@ -79,7 +79,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
       embeddedProps = overrideMeta.getProperties();
       embeddedPropsMap = new HashMap<>();
       for (BeanProperty embeddedProp : embeddedProps) {
-        embeddedPropsMap.put(embeddedProp.getName(), embeddedProp);
+        embeddedPropsMap.put(embeddedProp.name(), embeddedProp);
       }
     } else {
       embeddedProps = null;
@@ -129,15 +129,15 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
           // limit JoinColumn mapping to the @Id / primary key
           TableJoinColumn[] columns = tableJoin.columns();
           String foreignJoinColumn = columns[0].getForeignDbColumn();
-          String foreignIdColumn = targetDescriptor.getIdProperty().getDbColumn();
+          String foreignIdColumn = targetDescriptor.idProperty().dbColumn();
           if (!foreignJoinColumn.equalsIgnoreCase(foreignIdColumn)) {
-            throw new PersistenceException("Mapping limitation - @JoinColumn on " + getFullBeanName() + " needs to map to a primary key as per Issue #529 "
+            throw new PersistenceException("Mapping limitation - @JoinColumn on " + fullName() + " needs to map to a primary key as per Issue #529 "
               + " - joining to " + foreignJoinColumn + " and not " + foreignIdColumn);
           }
         }
       } else {
         exportedProperties = createExported();
-        String delStmt = "delete from " + targetDescriptor.getBaseTable() + " where ";
+        String delStmt = "delete from " + targetDescriptor.baseTable() + " where ";
         deleteByParentIdSql = delStmt + deriveWhereParentIdSql(false);
         deleteByParentIdInSql = delStmt + deriveWhereParentIdSql(true);
       }
@@ -154,6 +154,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
   /**
    * Return the property value as an entity bean.
    */
+  @Override
   public EntityBean getValueAsEntityBean(EntityBean owner) {
     return (EntityBean) getValue(owner);
   }
@@ -174,13 +175,13 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
    */
   void cacheClear() {
     if (cacheNotifyRelationship) {
-      targetDescriptor.cacheManyPropClear(relationshipProperty.getName());
+      targetDescriptor.cacheManyPropClear(relationshipProperty.name());
     }
   }
 
   void cacheClear(CacheChangeSet changeSet) {
     if (cacheNotifyRelationship) {
-      changeSet.addManyClear(targetDescriptor, relationshipProperty.getName());
+      changeSet.addManyClear(targetDescriptor, relationshipProperty.name());
     }
   }
 
@@ -190,19 +191,20 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
   void cacheDelete(boolean clear, EntityBean bean, CacheChangeSet changeSet) {
     if (cacheNotifyRelationship) {
       if (clear) {
-        changeSet.addManyClear(targetDescriptor, relationshipProperty.getName());
+        changeSet.addManyClear(targetDescriptor, relationshipProperty.name());
       } else {
         Object assocBean = getValue(bean);
         if (assocBean != null) {
-          Object parentId = targetDescriptor.getId((EntityBean) assocBean);
+          Object parentId = targetDescriptor.id(assocBean);
           if (parentId != null) {
-            changeSet.addManyRemove(targetDescriptor, relationshipProperty.getName(), parentId);
+            changeSet.addManyRemove(targetDescriptor, relationshipProperty.name(), parentId);
           }
         }
       }
     }
   }
 
+  @Override
   Object naturalKeyVal(Map<String, Object> values) {
     EntityBean bean = (EntityBean) values.get(name);
     if (bean == null) {
@@ -216,7 +218,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
     if (embedded) {
       BeanProperty embProp = embeddedPropsMap.get(remainder);
       if (embProp == null) {
-        String msg = "Embedded Property " + remainder + " not found in " + getFullBeanName();
+        String msg = "Embedded Property " + remainder + " not found in " + fullName();
         throw new PersistenceException(msg);
       }
       if (chain == null) {
@@ -230,7 +232,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
   }
 
   @Override
-  public String getElPlaceholder(boolean encrypted) {
+  public String elPlaceholder(boolean encrypted) {
     return encrypted ? elPlaceHolderEncrypted : elPlaceHolder;
   }
 
@@ -266,17 +268,17 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
   private List<Object> findIdsByParentId(Object parentId, Transaction t) {
     String rawWhere = deriveWhereParentIdSql(false);
     SpiEbeanServer server = server();
-    Query<?> q = server.find(getPropertyType());
+    Query<?> q = server.find(type());
     bindParentIdEq(rawWhere, parentId, q);
     return server.findIds(q, t);
   }
 
   private List<Object> findIdsByParentIdList(List<Object> parentIds, Transaction t) {
     String rawWhere = deriveWhereParentIdSql(true);
-    String inClause = getIdBinder().getIdInValueExpr(false, parentIds.size());
+    String inClause = idBinder().getIdInValueExpr(false, parentIds.size());
     String expr = rawWhere + inClause;
     SpiEbeanServer server = server();
-    Query<?> q = server.find(getPropertyType());
+    Query<?> q = server.find(type());
     bindParentIdsIn(expr, parentIds, q);
     return server.findIds(q, t);
   }
@@ -295,13 +297,13 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
       }
     } else {
       if (targetIdProperty != null) {
-        BeanDescriptor<T> target = getTargetDescriptor();
+        BeanDescriptor<T> target = targetDescriptor();
         String basePath = SplitName.add(prefix, name);
         if (dbColumn != null) {
-          BeanProperty idProperty = target.getIdProperty();
-          desc.registerColumn(dbColumn, SplitName.add(basePath, idProperty.getName()));
+          BeanProperty idProperty = target.idProperty();
+          desc.registerColumn(dbColumn, SplitName.add(basePath, idProperty.name()));
         }
-        desc.registerTable(target.getBaseTable(), this);
+        desc.registerTable(target.baseTable(), this);
       }
     }
   }
@@ -310,7 +312,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
    * Return meta data for the deployment of the embedded bean specific to this
    * property.
    */
-  public BeanProperty[] getProperties() {
+  public BeanProperty[] properties() {
     return embeddedProps;
   }
 
@@ -318,7 +320,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
   public void buildRawSqlSelectChain(String prefix, List<String> selectChain) {
     prefix = SplitName.add(prefix, name);
     if (!embedded) {
-      InheritInfo inheritInfo = targetDescriptor.getInheritInfo();
+      InheritInfo inheritInfo = targetDescriptor.inheritInfo();
       if (inheritInfo != null) {
         // expect the discriminator column to be included in order
         // to determine the inheritance type so we add it to the
@@ -328,7 +330,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
         selectChain.add(discProperty);
       }
       if (targetIdBinder == null) {
-        throw new IllegalStateException("No Id binding property for " + getFullBeanName()
+        throw new IllegalStateException("No Id binding property for " + fullName()
           + ". Probably a missing @OneToOne mapping annotation on this relationship?");
       }
       targetIdBinder.buildRawSqlSelectChain(prefix, selectChain);
@@ -339,6 +341,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
     }
   }
 
+  @Override
   public boolean hasForeignKey() {
     return foreignKey == null || primaryKeyJoin || !foreignKey.isNoConstraint();
   }
@@ -371,7 +374,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
 
     String nextPrefix = (prefix == null) ? name : prefix + "." + name;
     if (embedded) {
-      BeanDescriptor<T> targetDescriptor = getTargetDescriptor();
+      BeanDescriptor<T> targetDescriptor = targetDescriptor();
       targetDescriptor.diff(nextPrefix, map, (EntityBean) newEmb, (EntityBean) oldEmb);
 
     } else {
@@ -379,8 +382,8 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
       newBean = (EntityBean) newEmb;
       oldBean = (EntityBean) oldEmb;
 
-      BeanDescriptor<T> targetDescriptor = getTargetDescriptor();
-      BeanProperty idProperty = targetDescriptor.getIdProperty();
+      BeanDescriptor<T> targetDescriptor = targetDescriptor();
+      BeanProperty idProperty = targetDescriptor.idProperty();
 
       Object newId = (newBean == null) ? null : idProperty.getValue(newBean);
       Object oldId = (oldBean == null) ? null : idProperty.getValue(oldBean);
@@ -395,13 +398,14 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
    * represents.
    */
   @Override
-  public Class<?> getTargetType() {
-    return getPropertyType();
+  public Class<?> targetType() {
+    return type();
   }
 
   /**
    * Return the bean cache value for this property using original values.
    */
+  @Override
   public Object getCacheDataValueOrig(EntityBeanIntercept ebi) {
     return cacheDataConvert(ebi.getOrigValue(propertyIndex));
   }
@@ -420,19 +424,19 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
     } else if (targetInheritInfo != null) {
       return createCacheBeanId(ap);
     } else {
-      return targetDescriptor.getIdProperty().getCacheDataValue((EntityBean) ap);
+      return targetDescriptor.idProperty().getCacheDataValue((EntityBean) ap);
     }
   }
 
   private Object createCacheBeanId(Object bean) {
     final BeanDescriptor<?> desc = targetDescriptor.descOf(bean.getClass());
-    final Object id = desc.getIdProperty().getCacheDataValue((EntityBean) bean);
-    return new CachedBeanId(desc.getDiscValue(), id);
+    final Object id = desc.idProperty().getCacheDataValue((EntityBean) bean);
+    return new CachedBeanId(desc.discValue(), id);
   }
 
   @Override
   public String format(Object value) {
-    return targetDescriptor.getIdBinder().cacheKey(value);
+    return targetDescriptor.idBinder().cacheKey(value);
   }
 
   @Override
@@ -459,7 +463,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
 
   private Object refBean(BeanDescriptor<?> desc, Object id, PersistenceContext context) {
     if (id instanceof String) {
-      id = desc.getIdProperty().scalarType.parse((String) id);
+      id = desc.idProperty().scalarType.parse((String) id);
     }
     Object bean = desc.contextGet(context, id);
     if (bean == null) {
@@ -469,44 +473,44 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
   }
 
   @Override
-  public ScalarDataReader<?> getIdReader() {
-    return targetDescriptor.getIdProperty();
+  public ScalarDataReader<?> idReader() {
+    return targetDescriptor.idProperty();
   }
 
-  ScalarType<?> getIdScalarType() {
-    return targetDescriptor.getIdProperty().scalarType;
+  ScalarType<?> idScalarType() {
+    return targetDescriptor.idProperty().scalarType;
   }
 
   /**
    * Return the Id values from the given bean.
    */
   @Override
-  public Object[] getAssocIdValues(EntityBean bean) {
-    return targetDescriptor.getIdBinder().getIdValues(bean);
+  public Object[] assocIdValues(EntityBean bean) {
+    return targetDescriptor.idBinder().getIdValues(bean);
   }
 
   /**
    * Return the Id expression to add to where clause etc.
    */
   @Override
-  public String getAssocIdExpression(String prefix, String operator) {
-    return targetDescriptor.getIdBinder().getAssocOneIdExpr(prefix, operator);
+  public String assocIdExpression(String prefix, String operator) {
+    return targetDescriptor.idBinder().getAssocOneIdExpr(prefix, operator);
   }
 
   /**
    * Return the logical id value expression taking into account embedded id's.
    */
   @Override
-  public String getAssocIdInValueExpr(boolean not, int size) {
-    return targetDescriptor.getIdBinder().getIdInValueExpr(not, size);
+  public String assocIdInValueExpr(boolean not, int size) {
+    return targetDescriptor.idBinder().getIdInValueExpr(not, size);
   }
 
   /**
    * Return the logical id in expression taking into account embedded id's.
    */
   @Override
-  public String getAssocIdInExpr(String prefix) {
-    return targetDescriptor.getIdBinder().getAssocIdInExpr(prefix);
+  public String assocIdInExpr(String prefix) {
+    return targetDescriptor.idBinder().getAssocIdInExpr(prefix);
   }
 
   @Override
@@ -524,7 +528,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
    * value.
    */
   public Object createEmbeddedId() {
-    return getTargetDescriptor().createEntityBean();
+    return targetDescriptor().createEntityBean();
   }
 
   @Override
@@ -537,7 +541,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
     return value;
   }
 
-  public ImportedId getImportedId() {
+  public ImportedId importedId() {
     return importedId;
   }
 
@@ -561,11 +565,11 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
    * Create the array of ExportedProperty used to build reference objects.
    */
   private ExportedProperty[] createExported() {
-    BeanProperty idProp = descriptor.getIdProperty();
+    BeanProperty idProp = descriptor.idProperty();
     ArrayList<ExportedProperty> list = new ArrayList<>();
     if (idProp != null && idProp.isEmbedded()) {
       BeanPropertyAssocOne<?> one = (BeanPropertyAssocOne<?>) idProp;
-      BeanDescriptor<?> targetDesc = one.getTargetDescriptor();
+      BeanDescriptor<?> targetDesc = one.targetDescriptor();
       BeanProperty[] emIds = targetDesc.propertiesBaseScalar();
       try {
         for (BeanProperty emId : emIds) {
@@ -587,14 +591,14 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
    * Find the matching foreignDbColumn for a given local property.
    */
   private ExportedProperty findMatch(boolean embeddedProp, BeanProperty prop) {
-    return findMatch(embeddedProp, prop, prop.getDbColumn(), tableJoin);
+    return findMatch(embeddedProp, prop, prop.dbColumn(), tableJoin);
   }
 
   @Override
   public void appendSelect(DbSqlContext ctx, boolean subQuery) {
     if (!isTransient) {
       if (primaryKeyExport) {
-        descriptor.getIdProperty().appendSelect(ctx, subQuery);
+        descriptor.idProperty().appendSelect(ctx, subQuery);
       } else {
         localHelp.appendSelect(ctx, subQuery);
       }
@@ -728,7 +732,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
     if (value instanceof EntityBean) {
       if (embedded) {
         writeJson.writeFieldName(name);
-        BeanDescriptor<?> refDesc = descriptor.getBeanDescriptor(value.getClass());
+        BeanDescriptor<?> refDesc = descriptor.descriptor(value.getClass());
         refDesc.jsonWriteForInsert(writeJson, (EntityBean) value);
       } else {
         jsonWriteTargetId(writeJson, (EntityBean) value);
@@ -740,7 +744,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
    * Just write the Id property of the ToOne property.
    */
   private void jsonWriteTargetId(SpiJsonWriter writeJson, EntityBean childBean) throws IOException {
-    BeanProperty idProperty = targetDescriptor.getIdProperty();
+    BeanProperty idProperty = targetDescriptor.idProperty();
     if (idProperty != null) {
       writeJson.writeStartObject(name);
       idProperty.jsonWriteForInsert(writeJson, childBean);
@@ -761,7 +765,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
         // Hmmm, not writing complex non-entity bean
         if (value instanceof EntityBean) {
           writeJson.beginAssocOne(name, bean);
-          BeanDescriptor<?> refDesc = descriptor.getBeanDescriptor(value.getClass());
+          BeanDescriptor<?> refDesc = descriptor.descriptor(value.getClass());
           refDesc.jsonWrite(writeJson, (EntityBean) value, name);
           writeJson.endAssocOne();
         }
@@ -791,7 +795,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
       targetDescriptor.convertSetId(parentId, child);
     }
     if (mappedBy != null) {
-      BeanProperty beanProperty = targetDescriptor.getBeanProperty(mappedBy);
+      BeanProperty beanProperty = targetDescriptor.beanProperty(mappedBy);
       if (beanProperty != null && beanProperty.getValue(child) == null) {
         // set the 'parent' bean to the 'child' bean
         beanProperty.setValue(child, parent);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanSetHelp.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanSetHelp.java
index f275d0988..fd27bac16 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanSetHelp.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanSetHelp.java
@@ -54,7 +54,7 @@ public class BeanSetHelp<T> extends BaseCollectionHelp<T> {
   public BeanCollection<T> createEmpty(EntityBean ownerBean) {
     BeanSet<T> beanSet = new BeanSet<>(loader, ownerBean, propertyName);
     if (many != null) {
-      beanSet.setModifyListening(many.getModifyListenMode());
+      beanSet.setModifyListening(many.modifyListenMode());
     }
     return beanSet;
   }
@@ -62,7 +62,7 @@ public class BeanSetHelp<T> extends BaseCollectionHelp<T> {
   @Override
   public BeanCollection<T> createReference(EntityBean parentBean) {
     BeanSet<T> beanSet = new BeanSet<>(loader, parentBean, propertyName);
-    beanSet.setModifyListening(many.getModifyListenMode());
+    beanSet.setModifyListening(many.modifyListenMode());
     return beanSet;
   }
 
@@ -76,7 +76,7 @@ public class BeanSetHelp<T> extends BaseCollectionHelp<T> {
   public void refresh(BeanCollection<?> bc, EntityBean parentBean) {
     BeanSet<?> newBeanSet = (BeanSet<?>) bc;
     Set<?> current = (Set<?>) many.getValue(parentBean);
-    newBeanSet.setModifyListening(many.getModifyListenMode());
+    newBeanSet.setModifyListening(many.modifyListenMode());
     if (current == null) {
       // the currentList is null?  Not really expecting this...
       many.setValue(parentBean, newBeanSet);
@@ -85,7 +85,7 @@ public class BeanSetHelp<T> extends BaseCollectionHelp<T> {
       // normally this case, replace just the underlying list
       BeanSet<?> currentBeanSet = (BeanSet<?>) current;
       currentBeanSet.setActualSet(newBeanSet.getActualSet());
-      currentBeanSet.setModifyListening(many.getModifyListenMode());
+      currentBeanSet.setModifyListening(many.modifyListenMode());
 
     } else {
       // replace the entire set
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanTable.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanTable.java
index ecd0b7a37..dc283d53e 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanTable.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanTable.java
@@ -90,7 +90,7 @@ public final class BeanTable {
     }
     if (idProperty instanceof BeanPropertyAssocOne<?>) {
       BeanPropertyAssocOne<?> assocOne = (BeanPropertyAssocOne<?>) idProperty;
-      BeanProperty[] props = assocOne.getProperties();
+      BeanProperty[] props = assocOne.properties();
       for (BeanProperty prop : props) {
         addToJoin(foreignKeyPrefix, join, reverse, sqlFormulaSelect, true, prop);
       }
@@ -100,10 +100,10 @@ public final class BeanTable {
   }
 
   private void addToJoin(String foreignKeyPrefix, DeployTableJoin join, boolean reverse, String sqlFormulaSelect, boolean complexKey, BeanProperty prop) {
-    String lc = prop.getDbColumn();
+    String lc = prop.dbColumn();
     String fk = lc;
     if (foreignKeyPrefix != null) {
-      fk = owner.getNamingConvention().getForeignKey(foreignKeyPrefix, fk);
+      fk = owner.namingConvention().getForeignKey(foreignKeyPrefix, fk);
     }
     if (complexKey) {
       // just to copy the column name rather than prefix with the foreignKeyPrefix.
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DCacheRegion.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DCacheRegion.java
index d8867e904..0f9190782 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DCacheRegion.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DCacheRegion.java
@@ -12,7 +12,7 @@ public final class DCacheRegion implements SpiCacheRegion {
   }
 
   @Override
-  public String getName() {
+  public String name() {
     return name;
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DCacheRegionNone.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DCacheRegionNone.java
index c7b20095a..cdb7783bd 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DCacheRegionNone.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DCacheRegionNone.java
@@ -7,7 +7,7 @@ final class DCacheRegionNone implements SpiCacheRegion {
   static final SpiCacheRegion INSTANCE = new DCacheRegionNone();
 
   @Override
-  public String getName() {
+  public String name() {
     return "<none>";
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DeployPropertyParser.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DeployPropertyParser.java
index 419d1052e..a964ef1ee 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DeployPropertyParser.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DeployPropertyParser.java
@@ -56,15 +56,15 @@ public final class DeployPropertyParser extends DeployParser {
 
   @Override
   public String getDeployWord(String expression) {
-    ElPropertyDeploy elProp = beanDescriptor.getElPropertyDeploy(expression);
+    ElPropertyDeploy elProp = beanDescriptor.elPropertyDeploy(expression);
     if (elProp == null) {
       return null;
     } else {
       if (catchFirst && firstProp == null) {
         firstProp = elProp;
       }
-      addIncludes(elProp.getElPrefix());
-      return elProp.getElPlaceholder(encrypted);
+      addIncludes(elProp.elPrefix());
+      return elProp.elPlaceholder(encrypted);
     }
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DeployUpdateParser.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DeployUpdateParser.java
index 638029647..a59269eed 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DeployUpdateParser.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DeployUpdateParser.java
@@ -73,11 +73,11 @@ public final class DeployUpdateParser extends DeployParser {
 
   @Override
   public String getDeployWord(String expression) {
-    if (expression.equalsIgnoreCase(beanDescriptor.getName())) {
-      return beanDescriptor.getBaseTable();
+    if (expression.equalsIgnoreCase(beanDescriptor.name())) {
+      return beanDescriptor.baseTable();
     }
-    ElPropertyDeploy elProp = beanDescriptor.getElPropertyDeploy(expression);
-    return elProp != null ? elProp.getDbColumn() : null;
+    ElPropertyDeploy elProp = beanDescriptor.elPropertyDeploy(expression);
+    return elProp != null ? elProp.dbColumn() : null;
   }
 
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DynamicPropertyAggregationFormulaMTO.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DynamicPropertyAggregationFormulaMTO.java
index b9a8f008d..2b7127d8c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DynamicPropertyAggregationFormulaMTO.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DynamicPropertyAggregationFormulaMTO.java
@@ -8,7 +8,7 @@ public final class DynamicPropertyAggregationFormulaMTO extends DynamicPropertyA
   private final BeanPropertyAssocOne prop;
 
   DynamicPropertyAggregationFormulaMTO(BeanPropertyAssocOne prop, String name, String parsedFormula, boolean aggregate, BeanProperty asTarget, String alias) {
-    super(name, prop.getIdScalarType(), parsedFormula, aggregate, asTarget, alias);
+    super(name, prop.idScalarType(), parsedFormula, aggregate, asTarget, alias);
     this.prop = prop;
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DynamicPropertyBase.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DynamicPropertyBase.java
index 2bf722154..ceb22bf06 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DynamicPropertyBase.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DynamicPropertyBase.java
@@ -24,12 +24,12 @@ abstract class DynamicPropertyBase implements STreeProperty {
   }
 
   @Override
-  public String getName() {
+  public String name() {
     return name;
   }
 
   @Override
-  public String getFullBeanName() {
+  public String fullName() {
     return fullName;
   }
 
@@ -49,12 +49,12 @@ abstract class DynamicPropertyBase implements STreeProperty {
   }
 
   @Override
-  public String getElPrefix() {
+  public String elPrefix() {
     return elPrefix;
   }
 
   @Override
-  public ScalarType<?> getScalarType() {
+  public ScalarType<?> scalarType() {
     return scalarType;
   }
 
@@ -74,7 +74,7 @@ abstract class DynamicPropertyBase implements STreeProperty {
   }
 
   @Override
-  public String getEncryptKeyAsString() {
+  public String encryptKeyAsString() {
     return null;
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/ExportedProperty.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/ExportedProperty.java
index 72db83564..ae41492fd 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/ExportedProperty.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/ExportedProperty.java
@@ -54,6 +54,6 @@ final class ExportedProperty {
     if (path != null) {
       sb.append(path).append(".");
     }
-    sb.append(property.getName());
+    sb.append(property.name());
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/FormulaPropertyPath.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/FormulaPropertyPath.java
index bd294d145..ac9aaabb5 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/FormulaPropertyPath.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/FormulaPropertyPath.java
@@ -97,25 +97,25 @@ final class FormulaPropertyPath {
 
   STreeProperty build() {
     if (cast != null) {
-      ScalarType<?> scalarType = descriptor.getScalarType(cast);
+      ScalarType<?> scalarType = descriptor.scalarType(cast);
       if (scalarType == null) {
         throw new IllegalStateException("Unable to find scalarType for cast of [" + cast + "] on formula [" + formula + "] for type " + descriptor);
       }
       return create(scalarType);
     }
     if (isCount()) {
-      return create(descriptor.getScalarType(Types.BIGINT));
+      return create(descriptor.scalarType(Types.BIGINT));
     }
     if (isConcat()) {
-      return create(descriptor.getScalarType(Types.VARCHAR));
+      return create(descriptor.scalarType(Types.VARCHAR));
     }
     if (firstProp == null) {
       throw new IllegalStateException("unable to determine scalarType of formula [" + formula + "] for type " + descriptor + " - maybe use a cast like ::String ?");
     }
     // determine scalarType based on first property found by parser
-    final BeanProperty property = firstProp.getBeanProperty();
+    final BeanProperty property = firstProp.beanProperty();
     if (!property.isAssocId()) {
-      return create(property.getScalarType());
+      return create(property.scalarType());
     } else {
       return createManyToOne(property);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/InheritInfo.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/InheritInfo.java
index 2985170bf..3f0c5c8cb 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/InheritInfo.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/InheritInfo.java
@@ -80,9 +80,9 @@ public final class InheritInfo {
    */
   public void appendCheckConstraintValues(final String propertyName, final Set<String> checkConstraintValues) {
     visitChildren(inheritInfo -> {
-      BeanProperty prop = inheritInfo.desc().getBeanProperty(propertyName);
+      BeanProperty prop = inheritInfo.desc().beanProperty(propertyName);
       if (prop != null) {
-        Set<String> values = prop.getDbCheckConstraintValues();
+        Set<String> values = prop.dbCheckConstraintValues();
         if (values != null) {
           checkConstraintValues.addAll(values);
         }
@@ -236,7 +236,7 @@ public final class InheritInfo {
    * Return the IdBinder for this type.
    */
   public IdBinder getIdBinder() {
-    return descriptor.getIdBinder();
+    return descriptor.idBinder();
   }
 
   /**
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/IntersectionRow.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/IntersectionRow.java
index 3284032bb..f5480ac77 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/IntersectionRow.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/IntersectionRow.java
@@ -72,7 +72,7 @@ public final class IntersectionRow {
       sb.append("delete from ").append(tableName);
     } else {
       sb.append("update ").append(tableName).append(" set ");
-      sb.append(targetDescriptor.getSoftDeleteDbSet());
+      sb.append(targetDescriptor.softDeleteDbSet());
     }
     sb.append(" where ");
     int count = setBindParams(bindParams, sb);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/IdBinderEmbedded.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/IdBinderEmbedded.java
index 2edc359fc..e3b23e9fb 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/IdBinderEmbedded.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/IdBinderEmbedded.java
@@ -35,13 +35,13 @@ public final class IdBinderEmbedded implements IdBinder {
   public IdBinderEmbedded(boolean idInExpandedForm, BeanPropertyAssocOne<?> embIdProperty) {
     this.idInExpandedForm = idInExpandedForm;
     this.embIdProperty = embIdProperty;
-    this.idClass = "_idClass".equals(embIdProperty.getName());
+    this.idClass = "_idClass".equals(embIdProperty.name());
   }
 
   @Override
   public void initialise() {
-    this.idDesc = embIdProperty.getTargetDescriptor();
-    this.props = embIdProperty.getProperties();
+    this.idDesc = embIdProperty.targetDescriptor();
+    this.props = embIdProperty.properties();
     this.idInValueSql = idInExpandedForm ? idInExpanded() : idInCompressed();
   }
 
@@ -57,7 +57,7 @@ public final class IdBinderEmbedded implements IdBinder {
       if (i > 0) {
         sb.append(" and ");
       }
-      sb.append(idDesc.getBaseTableAlias()).append(".").append(props[i].getDbColumn()).append("=?");
+      sb.append(idDesc.baseTableAlias()).append(".").append(props[i].dbColumn()).append("=?");
     }
     sb.append(")");
     return sb.toString();
@@ -91,9 +91,9 @@ public final class IdBinderEmbedded implements IdBinder {
         sb.append(pathPrefix).append(".");
       }
       if (!idClass) {
-        sb.append(embIdProperty.getName()).append(".");
+        sb.append(embIdProperty.name()).append(".");
       }
-      sb.append(props[i].getName());
+      sb.append(props[i].name());
       if (!ascending) {
         sb.append(" desc");
       }
@@ -107,13 +107,13 @@ public final class IdBinderEmbedded implements IdBinder {
 
   @Override
   public String getIdProperty() {
-    return embIdProperty.getName();
+    return embIdProperty.name();
   }
 
   @Override
   public void buildRawSqlSelectChain(String prefix, List<String> selectChain) {
     if (!idClass) {
-      prefix = SplitName.add(prefix, embIdProperty.getName());
+      prefix = SplitName.add(prefix, embIdProperty.name());
     }
     for (BeanProperty prop : props) {
       prop.buildRawSqlSelectChain(prefix, selectChain);
@@ -123,7 +123,7 @@ public final class IdBinderEmbedded implements IdBinder {
   @Override
   public BeanProperty findBeanProperty(String dbColumnName) {
     for (BeanProperty prop : props) {
-      if (dbColumnName.equalsIgnoreCase(prop.getDbColumn())) {
+      if (dbColumnName.equalsIgnoreCase(prop.dbColumn())) {
         return prop;
       }
     }
@@ -143,9 +143,9 @@ public final class IdBinderEmbedded implements IdBinder {
         sb.append(", ");
       }
       if (!idClass) {
-        sb.append(embIdProperty.getName()).append(".");
+        sb.append(embIdProperty.name()).append(".");
       }
-      sb.append(props[i].getName());
+      sb.append(props[i].name());
     }
     return sb.toString();
   }
@@ -173,7 +173,7 @@ public final class IdBinderEmbedded implements IdBinder {
         if (i > 0) {
           sb.append(" and ");
         }
-        sb.append(props[i].getDbColumn()).append("=?");
+        sb.append(props[i].dbColumn()).append("=?");
       }
       sb.append(")");
     }
@@ -235,7 +235,7 @@ public final class IdBinderEmbedded implements IdBinder {
     EntityBean ebValue = (EntityBean) embIdProperty.getValue(bean);
     Map<String, Object> map = new LinkedHashMap<>();
     for (BeanProperty prop : props) {
-      map.put(prop.getName(), prop.getValue(ebValue));
+      map.put(prop.name(), prop.getValue(ebValue));
     }
     return map;
   }
@@ -249,7 +249,7 @@ public final class IdBinderEmbedded implements IdBinder {
     Map<String, Object> map = (Map<String, Object>) value;
     EntityBean idValue = idDesc.createEntityBean();
     for (BeanProperty prop : props) {
-      prop.setValue(idValue, map.get(prop.getName()));
+      prop.setValue(idValue, map.get(prop.name()));
     }
     return idValue;
   }
@@ -358,7 +358,7 @@ public final class IdBinderEmbedded implements IdBinder {
       if (prefix != null) {
         sb.append(prefix).append(".");
       }
-      sb.append(props[i].getName());
+      sb.append(props[i].name());
     }
     sb.append(")");
     return sb.toString();
@@ -375,9 +375,9 @@ public final class IdBinderEmbedded implements IdBinder {
         sb.append(prefix).append(".");
       }
       if (!idClass) {
-        sb.append(embIdProperty.getName()).append(".");
+        sb.append(embIdProperty.name()).append(".");
       }
-      sb.append(props[i].getName()).append(operator);
+      sb.append(props[i].name()).append(operator);
     }
     return sb.toString();
   }
@@ -392,7 +392,7 @@ public final class IdBinderEmbedded implements IdBinder {
       if (baseTableAlias != null) {
         sb.append(baseTableAlias).append(".");
       }
-      sb.append(props[i].getDbColumn()).append("=?");
+      sb.append(props[i].dbColumn()).append("=?");
     }
     return sb.toString();
   }
@@ -411,7 +411,7 @@ public final class IdBinderEmbedded implements IdBinder {
       if (baseTableAlias != null) {
         sb.append(baseTableAlias).append(".");
       }
-      sb.append(props[i].getDbColumn());
+      sb.append(props[i].dbColumn());
     }
     sb.append(")");
     return sb.toString();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/IdBinderSimple.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/IdBinderSimple.java
index 2dd025cb3..b0fd2da18 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/IdBinderSimple.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/IdBinderSimple.java
@@ -34,9 +34,9 @@ public final class IdBinderSimple implements IdBinder {
 
   public IdBinderSimple(BeanProperty idProperty, MultiValueBind multiValueBind) {
     this.idProperty = idProperty;
-    this.scalarType = idProperty.getScalarType();
-    this.expectedType = idProperty.getPropertyType();
-    bindIdSql = InternString.intern(idProperty.getDbColumn() + " = ? ");
+    this.scalarType = idProperty.scalarType();
+    this.expectedType = idProperty.type();
+    bindIdSql = InternString.intern(idProperty.dbColumn() + " = ? ");
     this.multiValueBind = multiValueBind;
   }
 
@@ -56,7 +56,7 @@ public final class IdBinderSimple implements IdBinder {
     if (pathPrefix != null) {
       sb.append(pathPrefix).append(".");
     }
-    sb.append(idProperty.getName());
+    sb.append(idProperty.name());
     if (!ascending) {
       sb.append(" desc");
     }
@@ -75,12 +75,12 @@ public final class IdBinderSimple implements IdBinder {
 
   @Override
   public String getIdProperty() {
-    return idProperty.getName();
+    return idProperty.name();
   }
 
   @Override
   public BeanProperty findBeanProperty(String dbColumnName) {
-    if (dbColumnName.equalsIgnoreCase(idProperty.getDbColumn())) {
+    if (dbColumnName.equalsIgnoreCase(idProperty.dbColumn())) {
       return idProperty;
     }
     return null;
@@ -93,15 +93,15 @@ public final class IdBinderSimple implements IdBinder {
 
   @Override
   public String getDefaultOrderBy() {
-    return idProperty.getName();
+    return idProperty.name();
   }
 
   @Override
   public String getBindIdInSql(String baseTableAlias) {
     if (baseTableAlias == null) {
-      return idProperty.getDbColumn();
+      return idProperty.dbColumn();
     } else {
-      return baseTableAlias + "." + idProperty.getDbColumn();
+      return baseTableAlias + "." + idProperty.dbColumn();
     }
   }
 
@@ -216,7 +216,7 @@ public final class IdBinderSimple implements IdBinder {
       sb.append(prefix);
       sb.append(".");
     }
-    sb.append(idProperty.getName());
+    sb.append(idProperty.name());
     sb.append(operator);
     return sb.toString();
   }
@@ -228,7 +228,7 @@ public final class IdBinderSimple implements IdBinder {
       sb.append(prefix);
       sb.append(".");
     }
-    sb.append(idProperty.getName());
+    sb.append(idProperty.name());
     return sb.toString();
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/ImportedIdEmbedded.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/ImportedIdEmbedded.java
index 54581a1be..5776b7ccc 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/ImportedIdEmbedded.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/ImportedIdEmbedded.java
@@ -32,11 +32,11 @@ public final class ImportedIdEmbedded implements ImportedId {
 
   @Override
   public void addFkeys(String name) {
-    BeanProperty[] embeddedProps = foreignAssocOne.getProperties();
+    BeanProperty[] embeddedProps = foreignAssocOne.properties();
     for (int i = 0; i < imported.length; i++) {
-      String n = name + "." + foreignAssocOne.getName() + "." + embeddedProps[i].getName();
-      BeanFkeyProperty fkey = new BeanFkeyProperty(n, imported[i].localDbColumn, foreignAssocOne.getDeployOrder());
-      owner.getBeanDescriptor().add(fkey);
+      String n = name + "." + foreignAssocOne.name() + "." + embeddedProps[i].name();
+      BeanFkeyProperty fkey = new BeanFkeyProperty(n, imported[i].localDbColumn, foreignAssocOne.deployOrder());
+      owner.descriptor().add(fkey);
     }
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/ImportedIdSimple.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/ImportedIdSimple.java
index 362ea51cc..df4c3272c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/ImportedIdSimple.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/id/ImportedIdSimple.java
@@ -88,8 +88,8 @@ public final class ImportedIdSimple implements ImportedId, Comparable<ImportedId
 
   @Override
   public void addFkeys(String name) {
-    BeanFkeyProperty fkey = new BeanFkeyProperty(name + "." + foreignProperty.getName(), localDbColumn, owner.getDeployOrder());
-    owner.getBeanDescriptor().add(fkey);
+    BeanFkeyProperty fkey = new BeanFkeyProperty(name + "." + foreignProperty.name(), localDbColumn, owner.deployOrder());
+    owner.descriptor().add(fkey);
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployBeanDescriptor.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployBeanDescriptor.java
index 8d1a735eb..e670dd136 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployBeanDescriptor.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployBeanDescriptor.java
@@ -192,7 +192,7 @@ public class DeployBeanDescriptor<T> {
    * Return the DeployBeanInfo for the given bean class.
    */
   DeployBeanInfo<?> getDeploy(Class<?> cls) {
-    return manager.getDeploy(cls);
+    return manager.deploy(cls);
   }
 
   public void setStorageEngine(String storageEngine) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployBeanPropertyLists.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployBeanPropertyLists.java
index a6ed9c330..df63155db 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployBeanPropertyLists.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployBeanPropertyLists.java
@@ -90,7 +90,7 @@ public final class DeployBeanPropertyLists {
         discProperty = null;
       }
       BeanProperty beanProp = createBeanProperty(owner, prop);
-      propertyMap.put(beanProp.getName(), beanProp);
+      propertyMap.put(beanProp.name(), beanProp);
     }
 
     int order = 0;
@@ -102,13 +102,13 @@ public final class DeployBeanPropertyLists {
     if (orderColumn != null) {
       orderColumn.setDeployOrder(order);
       allocateToList(orderColumn);
-      propertyMap.put(orderColumn.getName(), orderColumn);
+      propertyMap.put(orderColumn.name(), orderColumn);
     }
 
     if (discProperty != null) {
       // put the discriminator property into the property map only
       // (after the real properties have been organised into their lists)
-      propertyMap.put(discProperty.getName(), discProperty);
+      propertyMap.put(discProperty.name(), discProperty);
     }
   }
 
@@ -184,7 +184,7 @@ public final class DeployBeanPropertyLists {
     }
     if (prop.isId()) {
       if (id != null) {
-        throw new IllegalStateException("More that one @Id property on " + desc.getFullName() + " ?");
+        throw new IllegalStateException("More that one @Id property on " + desc.fullName() + " ?");
       }
       id = prop;
       return;
@@ -194,7 +194,7 @@ public final class DeployBeanPropertyLists {
       mutable.add(prop);
     }
 
-    if (desc.getInheritInfo() != null && prop.isLocal()) {
+    if (desc.inheritInfo() != null && prop.isLocal()) {
       local.add(prop);
     }
 
@@ -225,7 +225,7 @@ public final class DeployBeanPropertyLists {
           if (versionProperty == null) {
             versionProperty = prop;
           } else {
-            logger.warn("Multiple @Version properties - property " + prop.getFullBeanName() + " not treated as a version property");
+            logger.warn("Multiple @Version properties - property " + prop.fullName() + " not treated as a version property");
           }
         } else if (prop.isDraftDirty()) {
           draftDirty = prop;
@@ -356,7 +356,7 @@ public final class DeployBeanPropertyLists {
   public BeanProperty[] getGeneratedInsert() {
     List<BeanProperty> list = new ArrayList<>();
     for (BeanProperty prop : nonTransients) {
-      GeneratedProperty gen = prop.getGeneratedProperty();
+      GeneratedProperty gen = prop.generatedProperty();
       if (gen != null && gen.includeInInsert()) {
         list.add(prop);
       }
@@ -370,7 +370,7 @@ public final class DeployBeanPropertyLists {
   public BeanProperty[] getGeneratedUpdate() {
     List<BeanProperty> list = new ArrayList<>();
     for (BeanProperty prop : nonTransients) {
-      GeneratedProperty gen = prop.getGeneratedProperty();
+      GeneratedProperty gen = prop.generatedProperty();
       if (gen != null && gen.includeInUpdate()) {
         list.add(prop);
       }
@@ -391,12 +391,12 @@ public final class DeployBeanPropertyLists {
       if (imported != prop.isOneToOneExported()) {
         switch (mode) {
           case Save:
-            if (prop.getCascadeInfo().isSave()) {
+            if (prop.cascadeInfo().isSave()) {
               list.add(prop);
             }
             break;
           case Delete:
-            if (prop.getCascadeInfo().isDelete()) {
+            if (prop.cascadeInfo().isDelete()) {
               list.add(prop);
             }
             break;
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployTableJoinColumn.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployTableJoinColumn.java
index 7bd82c709..a3fa2797a 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployTableJoinColumn.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/meta/DeployTableJoinColumn.java
@@ -3,8 +3,6 @@ package io.ebeaninternal.server.deploy.meta;
 import io.ebeaninternal.server.deploy.BeanProperty;
 import io.ebeaninternal.server.deploy.BeanTable;
 
-import javax.persistence.JoinColumn;
-
 /**
  * A join pair of local and foreign properties.
  */
@@ -87,7 +85,7 @@ public final class DeployTableJoinColumn {
     if (localDbColumn == null) {
       BeanProperty idProperty = beanTable.getIdProperty();
       if (idProperty != null) {
-        localDbColumn = idProperty.getDbColumn();
+        localDbColumn = idProperty.dbColumn();
       }
     }
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssoc.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssoc.java
index 525034f41..191a43c40 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssoc.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssoc.java
@@ -29,7 +29,7 @@ abstract class AnnotationAssoc extends AnnotationParser {
   }
 
   BeanTable getBeanTable(DeployBeanPropertyAssoc<?> prop) {
-    return factory.getBeanTable(prop.getTargetType());
+    return factory.beanTable(prop.getTargetType());
   }
 
   private String errorMsgMissingBeanTable(Class<?> type, String from) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssocManys.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssocManys.java
index 804533565..736602695 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssocManys.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssocManys.java
@@ -154,13 +154,13 @@ final class AnnotationAssocManys extends AnnotationAssoc {
     if (!prop.getTableJoin().hasJoinColumns() && beanTable != null) {
       // use naming convention to define join (based on the bean name for this side of relationship)
       // A unidirectional OneToMany or OneToMany with no mappedBy property
-      NamingConvention nc = factory.getNamingConvention();
+      NamingConvention nc = factory.namingConvention();
       String fkeyPrefix = null;
       if (nc.isUseForeignKeyPrefix()) {
         fkeyPrefix = nc.getColumnFromProperty(descriptor.getBeanType(), descriptor.getName());
       }
       // Use the owning bean table to define the join
-      BeanTable owningBeanTable = factory.getBeanTable(descriptor.getBeanType());
+      BeanTable owningBeanTable = factory.beanTable(descriptor.getBeanType());
       owningBeanTable.createJoinColumn(fkeyPrefix, prop.getTableJoin(), false, prop.getSqlFormulaSelect());
     }
   }
@@ -190,7 +190,7 @@ final class AnnotationAssocManys extends AnnotationAssoc {
       fullTableName = descriptor.getBaseTable()+"_"+ CamelCaseHelper.toUnderscoreFromCamel(prop.getName());
     }
 
-    BeanTable localTable = factory.getBeanTable(descriptor.getBeanType());
+    BeanTable localTable = factory.beanTable(descriptor.getBeanType());
     if (collectionTable != null) {
       prop.getTableJoin().addJoinColumn(util, true, collectionTable.joinColumns(), localTable);
     }
@@ -198,8 +198,8 @@ final class AnnotationAssocManys extends AnnotationAssoc {
       BeanProperty localId = localTable.getIdProperty();
       if (localId != null) {
         // add foreign key based on convention
-        String fkColName = namingConvention.getForeignKey(descriptor.getBaseTable(), localId.getName());
-        prop.getTableJoin().addJoinColumn(new DeployTableJoinColumn(localId.getDbColumn(), fkColName));
+        String fkColName = namingConvention.getForeignKey(descriptor.getBaseTable(), localId.name());
+        prop.getTableJoin().addJoinColumn(new DeployTableJoinColumn(localId.dbColumn(), fkColName));
       }
     }
 
@@ -296,8 +296,8 @@ final class AnnotationAssocManys extends AnnotationAssoc {
   private void readJoinTable(JoinTable joinTable, DeployBeanPropertyAssocMany<?> prop) {
     String intTableName = getFullTableName(joinTable);
     if (intTableName.isEmpty()) {
-      BeanTable localTable = factory.getBeanTable(descriptor.getBeanType());
-      BeanTable otherTable = factory.getBeanTable(prop.getTargetType());
+      BeanTable localTable = factory.beanTable(descriptor.getBeanType());
+      BeanTable otherTable = factory.beanTable(prop.getTargetType());
       intTableName = getM2MJoinTableName(localTable, otherTable);
     }
 
@@ -362,8 +362,8 @@ final class AnnotationAssocManys extends AnnotationAssoc {
       intTableName = intJoin.getTable();
     }
 
-    BeanTable localTable = factory.getBeanTable(descriptor.getBeanType());
-    BeanTable otherTable = factory.getBeanTable(prop.getTargetType());
+    BeanTable localTable = factory.beanTable(descriptor.getBeanType());
+    BeanTable otherTable = factory.beanTable(prop.getTargetType());
 
     final String localTableName = localTable.getUnqualifiedBaseTable();
     final String otherTableName = otherTable.getUnqualifiedBaseTable();
@@ -386,8 +386,8 @@ final class AnnotationAssocManys extends AnnotationAssoc {
       BeanProperty localId = localTable.getIdProperty();
       if (localId != null) {
         // add the source to intersection join columns
-        String fkCol = namingConvention.deriveM2MColumn(localTableName, localId.getDbColumn());
-        intJoin.addJoinColumn(new DeployTableJoinColumn(localId.getDbColumn(), fkCol));
+        String fkCol = namingConvention.deriveM2MColumn(localTableName, localId.dbColumn());
+        intJoin.addJoinColumn(new DeployTableJoinColumn(localId.dbColumn(), fkCol));
       }
     }
 
@@ -396,8 +396,8 @@ final class AnnotationAssocManys extends AnnotationAssoc {
       BeanProperty otherId = otherTable.getIdProperty();
       if (otherId != null) {
         // set the intersection to dest table join columns
-        String fkCol = namingConvention.deriveM2MColumn(otherTableName, otherId.getDbColumn());
-        destJoin.addJoinColumn(new DeployTableJoinColumn(fkCol, otherId.getDbColumn()));
+        String fkCol = namingConvention.deriveM2MColumn(otherTableName, otherId.dbColumn());
+        destJoin.addJoinColumn(new DeployTableJoinColumn(fkCol, otherId.dbColumn()));
       }
     }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssocOnes.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssocOnes.java
index 6580d841e..b7fb12230 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssocOnes.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssocOnes.java
@@ -145,7 +145,7 @@ final class AnnotationAssocOnes extends AnnotationAssoc {
 
       } else {
         // use naming convention to define join.
-        NamingConvention nc = factory.getNamingConvention();
+        NamingConvention nc = factory.namingConvention();
 
         String fkeyPrefix = null;
         if (nc.isUseForeignKeyPrefix()) {
@@ -231,7 +231,7 @@ final class AnnotationAssocOnes extends AnnotationAssoc {
     if (!primaryKeyJoin.referencedColumnName().isEmpty()) {
       log.info("Automatically determining join columns for @PrimaryKeyJoinColumn - Ignoring PrimaryKeyJoinColumn.referencedColumnName attribute [{}] on {}", primaryKeyJoin.referencedColumnName(), prop.getFullBeanName());
     }
-    BeanTable baseBeanTable = factory.getBeanTable(info.getDescriptor().getBeanType());
+    BeanTable baseBeanTable = factory.beanTable(info.getDescriptor().getBeanType());
     String localPrimaryKey = baseBeanTable.getIdColumn();
     String foreignColumn = getBeanTable(prop).getIdColumn();
     prop.getTableJoin().addJoinColumn(new DeployTableJoinColumn(localPrimaryKey, foreignColumn, false, false));
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/visitor/VisitProperties.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/visitor/VisitProperties.java
index 70f05a6dc..8997c8380 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/visitor/VisitProperties.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/visitor/VisitProperties.java
@@ -21,11 +21,11 @@ public class VisitProperties {
   }
 
   protected void visitProperties(BeanDescriptor<?> desc, BeanPropertyVisitor propertyVisitor) {
-    BeanProperty idProp = desc.getIdProperty();
+    BeanProperty idProp = desc.idProperty();
     if (idProp != null) {
       visit(propertyVisitor, idProp);
     }
-    BeanPropertyAssocOne<?> unidirectional = desc.getUnidirectional();
+    BeanPropertyAssocOne<?> unidirectional = desc.unidirectional();
     if (unidirectional != null) {
       visit(propertyVisitor, unidirectional);
     }
@@ -51,7 +51,7 @@ public class VisitProperties {
       if (assocOne.isEmbedded()) {
         // Embedded bean
         pv.visitEmbedded(assocOne);
-        BeanProperty[] embProps = assocOne.getProperties();
+        BeanProperty[] embProps = assocOne.properties();
         for (BeanProperty embProp : embProps) {
           pv.visitEmbeddedScalar(embProp, assocOne);
         }
@@ -73,7 +73,7 @@ public class VisitProperties {
    * Visit all the other inheritance properties that are not on the root.
    */
   protected void visitInheritanceProperties(BeanDescriptor<?> descriptor, BeanPropertyVisitor pv) {
-    InheritInfo inheritInfo = descriptor.getInheritInfo();
+    InheritInfo inheritInfo = descriptor.inheritInfo();
     if (inheritInfo != null && inheritInfo.isRoot()) {
       // add all properties on the children objects
       inheritInfo.visitChildren(new InheritChildVisitor(this, pv));
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/dto/DtoQueryPlanBase.java b/ebean-core/src/main/java/io/ebeaninternal/server/dto/DtoQueryPlanBase.java
index 51828c77f..bc0b013e9 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/dto/DtoQueryPlanBase.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/dto/DtoQueryPlanBase.java
@@ -12,7 +12,7 @@ abstract class DtoQueryPlanBase implements DtoQueryPlan {
 
   DtoQueryPlanBase(DtoMappingRequest request) {
     this.planMetric = request.createMetric();
-    this.metric = planMetric.getMetric();
+    this.metric = planMetric.metric();
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/el/ElComparatorProperty.java b/ebean-core/src/main/java/io/ebeaninternal/server/el/ElComparatorProperty.java
index 56576d947..bddcf5310 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/el/ElComparatorProperty.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/el/ElComparatorProperty.java
@@ -43,13 +43,13 @@ public final class ElComparatorProperty<T> implements Comparator<T>, ElComparato
       return val2 == null ? 0 : nullOrder;
     }
     if (elGetValue.isAssocId()) {
-      val1 = elGetValue.getAssocIdValues((EntityBean) val1)[0]; // TODO: compound key not yet supported
+      val1 = elGetValue.assocIdValues((EntityBean) val1)[0]; // TODO: compound key not yet supported
     }
     if (val2 == null) {
       return -1 * nullOrder;
     }
     if (elGetValue.isAssocId()) {
-      val2 = elGetValue.getAssocIdValues((EntityBean) val2)[0];
+      val2 = elGetValue.assocIdValues((EntityBean) val2)[0];
     }
     Comparable c = (Comparable) val1;
     return asc * c.compareTo(val2);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/el/ElFilter.java b/ebean-core/src/main/java/io/ebeaninternal/server/el/ElFilter.java
index 470345a31..6f8aec3aa 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/el/ElFilter.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/el/ElFilter.java
@@ -24,18 +24,18 @@ public final class ElFilter<T> implements Filter<T> {
 
   private Object convertValue(String propertyName, Object value) {
     // convert type of value to match expected type
-    ElPropertyValue elGetValue = beanDescriptor.getElGetValue(propertyName);
+    ElPropertyValue elGetValue = beanDescriptor.elGetValue(propertyName);
     return elGetValue.convert(value);
   }
 
   private ElComparator<T> getElComparator(String propertyName) {
 
-    return beanDescriptor.getElComparator(propertyName);
+    return beanDescriptor.elComparator(propertyName);
   }
 
   private ElPropertyValue getElGetValue(String propertyName) {
 
-    return beanDescriptor.getElGetValue(propertyName);
+    return beanDescriptor.elGetValue(propertyName);
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyChain.java b/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyChain.java
index 16d0e3808..d10acaedc 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyChain.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyChain.java
@@ -59,9 +59,9 @@ public final class ElPropertyChain implements ElPropertyValue {
     this.assocId = chain[chain.length - 1].isAssocId();
 
     this.last = chain.length - 1;
-    this.lastBeanProperty = chain[chain.length - 1].getBeanProperty();
+    this.lastBeanProperty = chain[chain.length - 1].beanProperty();
     if (lastBeanProperty != null) {
-      this.scalarType = lastBeanProperty.getScalarType();
+      this.scalarType = lastBeanProperty.scalarType();
     } else {
       // case for nested compound type (non-scalar)
       this.scalarType = null;
@@ -77,8 +77,8 @@ public final class ElPropertyChain implements ElPropertyValue {
   }
 
   @Override
-  public int getFetchPreference() {
-    return chain[0].getFetchPreference();
+  public int fetchPreference() {
+    return chain[0].fetchPreference();
   }
 
   @Override
@@ -88,9 +88,9 @@ public final class ElPropertyChain implements ElPropertyValue {
 
   private String getElPlaceHolder(String prefix, ElPropertyValue lastElPropertyValue, boolean encrypted) {
     if (prefix == null) {
-      return lastElPropertyValue.getElPlaceholder(encrypted);
+      return lastElPropertyValue.elPlaceholder(encrypted);
     }
-    String el = lastElPropertyValue.getElPlaceholder(encrypted);
+    String el = lastElPropertyValue.elPlaceholder(encrypted);
     if (!el.contains("${}")) {
       // typically a secondary table property
       return el.replace("${", "${" + prefix + ".");
@@ -113,7 +113,7 @@ public final class ElPropertyChain implements ElPropertyValue {
     }
     int i = 1 + SplitName.count(sinceProperty);
     for (; i < chain.length; i++) {
-      if (chain[i].getBeanProperty().containsMany()) {
+      if (chain[i].beanProperty().containsMany()) {
         return true;
       }
     }
@@ -131,22 +131,22 @@ public final class ElPropertyChain implements ElPropertyValue {
   }
 
   @Override
-  public String getElPrefix() {
+  public String elPrefix() {
     return prefix;
   }
 
   @Override
-  public String getName() {
+  public String name() {
     return name;
   }
 
   @Override
-  public String getElName() {
+  public String elName() {
     return expression;
   }
 
   @Override
-  public String getElPlaceholder(boolean encrypted) {
+  public String elPlaceholder(boolean encrypted) {
     return encrypted ? placeHolderEncrypted : placeHolder;
   }
 
@@ -166,30 +166,30 @@ public final class ElPropertyChain implements ElPropertyValue {
   }
 
   @Override
-  public String getAssocIsEmpty(SpiExpressionRequest request, String path) {
-    return lastElPropertyValue.getAssocIsEmpty(request, path);
+  public String assocIsEmpty(SpiExpressionRequest request, String path) {
+    return lastElPropertyValue.assocIsEmpty(request, path);
   }
 
   @Override
-  public Object[] getAssocIdValues(EntityBean bean) {
+  public Object[] assocIdValues(EntityBean bean) {
     // Don't navigate the object graph as bean
     // is assumed to be the appropriate type
-    return lastElPropertyValue.getAssocIdValues(bean);
+    return lastElPropertyValue.assocIdValues(bean);
   }
 
   @Override
-  public String getAssocIdExpression(String prefix, String operator) {
-    return lastElPropertyValue.getAssocIdExpression(expression, operator);
+  public String assocIdExpression(String prefix, String operator) {
+    return lastElPropertyValue.assocIdExpression(expression, operator);
   }
 
   @Override
-  public String getAssocIdInExpr(String prefix) {
-    return lastElPropertyValue.getAssocIdInExpr(prefix);
+  public String assocIdInExpr(String prefix) {
+    return lastElPropertyValue.assocIdInExpr(prefix);
   }
 
   @Override
-  public String getAssocIdInValueExpr(boolean not, int size) {
-    return lastElPropertyValue.getAssocIdInValueExpr(not, size);
+  public String assocIdInValueExpr(boolean not, int size) {
+    return lastElPropertyValue.assocIdInValueExpr(not, size);
   }
 
   @Override
@@ -198,7 +198,7 @@ public final class ElPropertyChain implements ElPropertyValue {
   }
 
   @Override
-  public Property getProperty() {
+  public Property property() {
     return lastBeanProperty;
   }
 
@@ -218,12 +218,12 @@ public final class ElPropertyChain implements ElPropertyValue {
   }
 
   @Override
-  public String getDbColumn() {
-    return lastElPropertyValue.getDbColumn();
+  public String dbColumn() {
+    return lastElPropertyValue.dbColumn();
   }
 
   @Override
-  public BeanProperty getBeanProperty() {
+  public BeanProperty beanProperty() {
     return lastBeanProperty;
   }
 
@@ -234,7 +234,7 @@ public final class ElPropertyChain implements ElPropertyValue {
   }
 
   @Override
-  public int getJdbcType() {
+  public int jdbcType() {
     return scalarType == null ? 0 : scalarType.getJdbcType();
   }
 
@@ -244,7 +244,7 @@ public final class ElPropertyChain implements ElPropertyValue {
   }
 
   @Override
-  public StringParser getStringParser() {
+  public StringParser stringParser() {
     return scalarType;
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyDeploy.java b/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyDeploy.java
index 17f4cfb29..e5e491b98 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyDeploy.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyDeploy.java
@@ -40,7 +40,7 @@ public interface ElPropertyDeploy {
    * this property.
    * </p>
    */
-  String getElPrefix();
+  String elPrefix();
 
   /**
    * Return the place holder in the form of ${elPrefix}dbColumn.
@@ -48,27 +48,27 @@ public interface ElPropertyDeploy {
    * The ${elPrefix} is replaced by the appropriate table alias.
    * </p>
    */
-  String getElPlaceholder(boolean encrypted);
+  String elPlaceholder(boolean encrypted);
 
   /**
    * Return the name of the property.
    */
-  String getName();
+  String name();
 
   /**
    * The ElPrefix plus name.
    */
-  String getElName();
+  String elName();
 
   /**
    * Return the deployment db column for this property.
    */
-  String getDbColumn();
+  String dbColumn();
 
   /**
    * Return the underlying bean property.
    */
-  BeanProperty getBeanProperty();
+  BeanProperty beanProperty();
 
   /**
    * Return true if this is an aggregation property.
@@ -79,5 +79,5 @@ public interface ElPropertyDeploy {
    * Return the fetch preference. This can be used to control which ToMany relationship
    * is left as a 'join' and which get converted to query join.
    */
-  int getFetchPreference();
+  int fetchPreference();
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyValue.java b/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyValue.java
index f69b33040..e43559560 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyValue.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/el/ElPropertyValue.java
@@ -14,17 +14,17 @@ public interface ElPropertyValue extends ElPropertyDeploy, ExpressionPath {
   /**
    * Return the logical id value expression taking into account embedded id's.
    */
-  String getAssocIdInValueExpr(boolean not, int size);
+  String assocIdInValueExpr(boolean not, int size);
 
   /**
    * Return the logical id in expression taking into account embedded id's.
    */
-  String getAssocIdInExpr(String prefix);
+  String assocIdInExpr(String prefix);
 
   /**
    * Return the logical where clause to support "Is empty".
    */
-  String getAssocIsEmpty(SpiExpressionRequest request, String path);
+  String assocIsEmpty(SpiExpressionRequest request, String path);
 
   /**
    * Return true if this is an ManyToOne or OneToOne associated bean property.
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/AbstractExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/AbstractExpression.java
index f3c9d5aae..cd18cec99 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/AbstractExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/AbstractExpression.java
@@ -56,7 +56,7 @@ abstract class AbstractExpression implements SpiExpression {
 
   protected String propertyNestedPath(String propertyName, BeanDescriptor<?> desc) {
     if (propertyName != null) {
-      ElPropertyDeploy elProp = desc.getElPropertyDeploy(propertyName);
+      ElPropertyDeploy elProp = desc.elPropertyDeploy(propertyName);
       if (elProp != null && elProp.containsMany()) {
         return SplitName.begin(propName);
       }
@@ -74,7 +74,7 @@ abstract class AbstractExpression implements SpiExpression {
    */
   protected void propertyContainsMany(String propertyName, BeanDescriptor<?> desc, ManyWhereJoins manyWhereJoin) {
     if (propertyName != null) {
-      ElPropertyDeploy elProp = desc.getElPropertyDeploy(propertyName);
+      ElPropertyDeploy elProp = desc.elPropertyDeploy(propertyName);
       if (elProp != null) {
         if (elProp.containsFormulaWithJoin()) {
           // for findCount query select clause
@@ -102,6 +102,6 @@ abstract class AbstractExpression implements SpiExpression {
   }
 
   protected final ElPropertyValue getElProp(SpiExpressionRequest request) {
-    return request.getBeanDescriptor().getElGetValue(propName);
+    return request.getBeanDescriptor().elGetValue(propName);
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/AllEqualsExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/AllEqualsExpression.java
index fafb3bc96..52d31c6dc 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/AllEqualsExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/AllEqualsExpression.java
@@ -39,7 +39,7 @@ final class AllEqualsExpression extends NonPrepareExpression {
   public void containsMany(BeanDescriptor<?> desc, ManyWhereJoins manyWhereJoin) {
     if (propMap != null) {
       for (String propertyName : propMap.keySet()) {
-        ElPropertyDeploy elProp = desc.getElPropertyDeploy(name(propertyName));
+        ElPropertyDeploy elProp = desc.elPropertyDeploy(name(propertyName));
         if (elProp != null && elProp.containsMany()) {
           manyWhereJoin.add(elProp);
         }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/BetweenPropertyExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/BetweenPropertyExpression.java
index 74129849d..0dfa1fc33 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/BetweenPropertyExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/BetweenPropertyExpression.java
@@ -52,7 +52,7 @@ final class BetweenPropertyExpression extends NonPrepareExpression {
 
   @Override
   public String nestedPath(BeanDescriptor<?> desc) {
-    ElPropertyDeploy elProp = desc.getElPropertyDeploy(name(lowProperty));
+    ElPropertyDeploy elProp = desc.elPropertyDeploy(name(lowProperty));
     if (elProp != null && elProp.containsMany()) {
       // assumes highProperty is also nested property which seems reasonable
       return SplitName.begin(lowProperty);
@@ -62,11 +62,11 @@ final class BetweenPropertyExpression extends NonPrepareExpression {
 
   @Override
   public void containsMany(BeanDescriptor<?> desc, ManyWhereJoins manyWhereJoin) {
-    ElPropertyDeploy elProp = desc.getElPropertyDeploy(name(lowProperty));
+    ElPropertyDeploy elProp = desc.elPropertyDeploy(name(lowProperty));
     if (elProp != null && elProp.containsMany()) {
       manyWhereJoin.add(elProp);
     }
-    elProp = desc.getElPropertyDeploy(name(highProperty));
+    elProp = desc.elPropertyDeploy(name(highProperty));
     if (elProp != null && elProp.containsMany()) {
       manyWhereJoin.add(elProp);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpression.java
index a8075090a..0d9f39fc5 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpression.java
@@ -37,7 +37,7 @@ final class CaseInsensitiveEqualExpression extends AbstractValueExpression {
     ElPropertyValue prop = getElProp(request);
     if (prop != null && prop.isDbEncrypted()) {
       // bind the key as well as the value
-      String encryptKey = prop.getBeanProperty().getEncryptKey().getStringValue();
+      String encryptKey = prop.beanProperty().encryptKey().getStringValue();
       request.addBindEncryptKey(encryptKey);
     }
 
@@ -49,7 +49,7 @@ final class CaseInsensitiveEqualExpression extends AbstractValueExpression {
     String pname = propName;
     ElPropertyValue prop = getElProp(request);
     if (prop != null && prop.isDbEncrypted()) {
-      pname = prop.getBeanProperty().getDecryptProperty(propName);
+      pname = prop.beanProperty().decryptProperty(propName);
     }
     if (not) {
       request.append("lower(").append(pname).append(") != ?");
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/DefaultExampleExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/DefaultExampleExpression.java
index ca97b5408..372e5ecab 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/DefaultExampleExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/DefaultExampleExpression.java
@@ -276,7 +276,7 @@ final class DefaultExampleExpression implements SpiExpression, ExampleExpression
       if (!beanProperty.isTransient()) {
         Object value = beanProperty.getValue(bean);
         if (value != null) {
-          String propName = SplitName.add(prefix, beanProperty.getName());
+          String propName = SplitName.add(prefix, beanProperty.name());
           if (beanProperty.isScalar()) {
             if (value instanceof String) {
               list.add(new LikeExpression(propName, value, caseInsensitive, likeType));
@@ -290,7 +290,7 @@ final class DefaultExampleExpression implements SpiExpression, ExampleExpression
 
           } else if ((beanProperty instanceof BeanPropertyAssocOne) && (value instanceof EntityBean)) {
             BeanPropertyAssocOne<?> assocOne = (BeanPropertyAssocOne<?>) beanProperty;
-            BeanDescriptor<?> targetDescriptor = assocOne.getTargetDescriptor();
+            BeanDescriptor<?> targetDescriptor = assocOne.targetDescriptor();
             addExpressions(list, targetDescriptor, (EntityBean) value, propName);
           }
         }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/DefaultExpressionRequest.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/DefaultExpressionRequest.java
index 09ff401af..89273c230 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/DefaultExpressionRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/DefaultExpressionRequest.java
@@ -28,7 +28,7 @@ public final class DefaultExpressionRequest implements SpiExpressionRequest {
 
   public DefaultExpressionRequest(SpiOrmQueryRequest<?> queryRequest, DeployParser deployParser, Binder binder, SpiExpressionList<?> expressionList) {
     this.queryRequest = queryRequest;
-    this.beanDescriptor = queryRequest.getBeanDescriptor();
+    this.beanDescriptor = queryRequest.descriptor();
     this.deployParser = deployParser;
     this.binder = binder;
     this.expressionList = expressionList;
@@ -84,7 +84,7 @@ public final class DefaultExpressionRequest implements SpiExpressionRequest {
   @Override
   public void appendLike(boolean rawLikeExpression) {
     sql.append(" ");
-    sql.append(queryRequest.getDBLikeClause(rawLikeExpression));
+    sql.append(queryRequest.dbLikeClause(rawLikeExpression));
     sql.append(" ");
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/ExistsQueryExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/ExistsQueryExpression.java
index 438f1a2d5..cf5a6ec99 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/ExistsQueryExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/ExistsQueryExpression.java
@@ -79,7 +79,7 @@ final class ExistsQueryExpression implements SpiExpression, UnsupportedDocStoreE
    */
   protected CQuery<?> compileSubQuery(BeanQueryRequest<?> queryRequest) {
     SpiEbeanServer ebeanServer = (SpiEbeanServer) queryRequest.getEbeanServer();
-    return ebeanServer.compileQuery(Type.SQ_EXISTS, subQuery, queryRequest.getTransaction());
+    return ebeanServer.compileQuery(Type.SQ_EXISTS, subQuery, queryRequest.transaction());
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/IdExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/IdExpression.java
index c61f884a4..d7f5e5a16 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/IdExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/IdExpression.java
@@ -54,7 +54,7 @@ final class IdExpression extends NonPrepareExpression implements SpiExpression {
     // 'flatten' EmbeddedId and multiple Id cases
     // into an array of the underlying scalar field values
     DefaultExpressionRequest r = (DefaultExpressionRequest) request;
-    Object[] bindIdValues = r.getBeanDescriptor().getBindIdValues(value);
+    Object[] bindIdValues = r.getBeanDescriptor().bindIdValues(value);
     for (Object bindIdValue : bindIdValues) {
       request.addBindValue(bindIdValue);
     }
@@ -64,7 +64,7 @@ final class IdExpression extends NonPrepareExpression implements SpiExpression {
   public void addSql(SpiExpressionRequest request) {
 
     DefaultExpressionRequest r = (DefaultExpressionRequest) request;
-    String idSql = r.getBeanDescriptor().getIdBinderIdSql(null);
+    String idSql = r.getBeanDescriptor().idBinderIdSql(null);
 
     request.append(idSql);
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/IdInExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/IdInExpression.java
index c1bd76db0..18e1c8be6 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/IdInExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/IdInExpression.java
@@ -81,7 +81,7 @@ public final class IdInExpression extends NonPrepareExpression {
 
     DefaultExpressionRequest r = (DefaultExpressionRequest) request;
     BeanDescriptor<?> descriptor = r.getBeanDescriptor();
-    IdBinder idBinder = descriptor.getIdBinder();
+    IdBinder idBinder = descriptor.idBinder();
     idBinder.addIdInBindValues(request, idCollection);
   }
 
@@ -92,11 +92,11 @@ public final class IdInExpression extends NonPrepareExpression {
 
     DefaultExpressionRequest r = (DefaultExpressionRequest) request;
     BeanDescriptor<?> descriptor = r.getBeanDescriptor();
-    IdBinder idBinder = descriptor.getIdBinder();
+    IdBinder idBinder = descriptor.idBinder();
     if (idCollection.isEmpty()) {
       request.append(SQL_FALSE); // append false for this stage
     } else {
-      request.append(descriptor.getIdBinder().getBindIdInSql(null));
+      request.append(descriptor.idBinder().getBindIdInSql(null));
       String inClause = idBinder.getIdInValueExpr(false, idCollection.size());
       request.append(inClause);
     }
@@ -105,15 +105,15 @@ public final class IdInExpression extends NonPrepareExpression {
   @Override
   public void addSql(SpiExpressionRequest request) {
     BeanDescriptor<?> descriptor = request.getBeanDescriptor();
-    IdBinder idBinder = descriptor.getIdBinder();
+    IdBinder idBinder = descriptor.idBinder();
     if (idCollection.isEmpty()) {
       request.append(SQL_FALSE); // append false for this stage
     } else {
       if (idBinder.isComplexId()) {
-        request.append(descriptor.getIdBinderInLHSSql());
+        request.append(descriptor.idBinderInLHSSql());
         request.append(idBinder.getIdInValueExpr(false, idCollection.size()));
       } else {
-        request.append(idBinder.getBeanProperty().getName());
+        request.append(idBinder.getBeanProperty().name());
         request.appendInExpression(false, idCollection);
       }
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/InExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/InExpression.java
index 1a84d87eb..16b79c1f4 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/InExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/InExpression.java
@@ -117,7 +117,7 @@ final class InExpression extends AbstractExpression {
       List<Object> idList = new ArrayList<>();
       for (Object bindValue : bindValues) {
         // extract the id values from the bean
-        Object[] ids = prop.getAssocIdValues((EntityBean) bindValue);
+        Object[] ids = prop.assocIdValues((EntityBean) bindValue);
         if (ids != null) {
           Collections.addAll(idList, ids);
         }
@@ -145,8 +145,8 @@ final class InExpression extends AbstractExpression {
     }
 
     if (prop != null) {
-      request.append(prop.getAssocIdInExpr(propName));
-      request.append(prop.getAssocIdInValueExpr(not, bindValues.size()));
+      request.append(prop.assocIdInExpr(propName));
+      request.append(prop.assocIdInValueExpr(not, bindValues.size()));
     } else {
       request.append(propName);
       request.appendInExpression(not, bindValues);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/InQueryExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/InQueryExpression.java
index e53792550..6e80916a0 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/InQueryExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/InQueryExpression.java
@@ -67,7 +67,7 @@ final class InQueryExpression extends AbstractExpression implements UnsupportedD
   private CQuery<?> compileSubQuery(BeanQueryRequest<?> queryRequest) {
 
     SpiEbeanServer ebeanServer = (SpiEbeanServer) queryRequest.getEbeanServer();
-    return ebeanServer.compileQuery(Type.SQ_IN, subQuery, queryRequest.getTransaction());
+    return ebeanServer.compileQuery(Type.SQ_IN, subQuery, queryRequest.transaction());
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/IsEmptyExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/IsEmptyExpression.java
index fc3be3e34..9896891de 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/IsEmptyExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/IsEmptyExpression.java
@@ -84,7 +84,7 @@ final class IsEmptyExpression extends AbstractExpression {
     }
     request
       .append("exists (select 1 from ")
-      .append(prop.getAssocIsEmpty(request, propertyPath))
+      .append(prop.assocIsEmpty(request, propertyPath))
       .append(")");
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/LikeExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/LikeExpression.java
index bf3871c23..e0b137154 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/LikeExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/LikeExpression.java
@@ -29,7 +29,7 @@ final class LikeExpression extends AbstractValueExpression {
     ElPropertyValue prop = getElProp(request);
     if (prop != null && prop.isDbEncrypted()) {
       // bind the key as well as the value
-      String encryptKey = prop.getBeanProperty().getEncryptKey().getStringValue();
+      String encryptKey = prop.beanProperty().encryptKey().getStringValue();
       request.addBindEncryptKey(encryptKey);
     }
     String bindValue = getValue(strValue(), caseInsensitive, type, request);
@@ -41,7 +41,7 @@ final class LikeExpression extends AbstractValueExpression {
     String pname = propName;
     ElPropertyValue prop = getElProp(request);
     if (prop != null && prop.isDbEncrypted()) {
-      pname = prop.getBeanProperty().getDecryptProperty(propName);
+      pname = prop.beanProperty().decryptProperty(propName);
     }
     if (caseInsensitive) {
       request.append("lower(").append(pname).append(")");
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/NativeILikeExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/NativeILikeExpression.java
index 110442365..9977c92e2 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/NativeILikeExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/NativeILikeExpression.java
@@ -28,7 +28,7 @@ final class NativeILikeExpression extends AbstractExpression {
     ElPropertyValue prop = getElProp(request);
     if (prop != null && prop.isDbEncrypted()) {
       // bind the key as well as the value
-      String encryptKey = prop.getBeanProperty().getEncryptKey().getStringValue();
+      String encryptKey = prop.beanProperty().encryptKey().getStringValue();
       request.addBindEncryptKey(encryptKey);
     }
     request.addBindValue(val);
@@ -40,7 +40,7 @@ final class NativeILikeExpression extends AbstractExpression {
     String pname = propName;
     ElPropertyValue prop = getElProp(request);
     if (prop != null && prop.isDbEncrypted()) {
-      pname = prop.getBeanProperty().getDecryptProperty(propName);
+      pname = prop.beanProperty().decryptProperty(propName);
     }
 
     request.append(pname).append(" ilike ?");
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/NullExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/NullExpression.java
index 4a4a81201..0c3eb00b5 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/NullExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/NullExpression.java
@@ -31,7 +31,7 @@ final class NullExpression extends AbstractExpression {
 
   @Override
   public void containsMany(BeanDescriptor<?> desc, ManyWhereJoins manyWhereJoin) {
-    elProperty = desc.getElGetValue(propName);
+    elProperty = desc.elGetValue(propName);
     if (elProperty != null && elProperty.isAssocMany()) {
       // it is OneToMany or ManyToMany so going to be treated as isEmpty() expression
       assocMany = true;
@@ -66,7 +66,7 @@ final class NullExpression extends AbstractExpression {
 
     String nullExpr = notNull ? " is not null" : " is null";
     if (elProperty != null && elProperty.isAssocId()) {
-      request.append(elProperty.getAssocIdExpression(propName, nullExpr));
+      request.append(elProperty.assocIdExpression(propName, nullExpr));
     } else {
       request.append(propName).append(nullExpr);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/expression/SimpleExpression.java b/ebean-core/src/main/java/io/ebeaninternal/server/expression/SimpleExpression.java
index 87b0ed3bf..aed3825ca 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/expression/SimpleExpression.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/expression/SimpleExpression.java
@@ -44,8 +44,8 @@ public final class SimpleExpression extends AbstractValueExpression {
     }
     ExpressionPath prop = context.getExpressionPath(propName);
     if (prop != null && prop.isAssocId()) {
-      String idName = prop.getAssocIdExpression(propName, "");
-      Object[] ids = prop.getAssocIdValues((EntityBean) value());
+      String idName = prop.assocIdExpression(propName, "");
+      Object[] ids = prop.assocIdValues((EntityBean) value());
       if (ids == null || ids.length != 1) {
         throw new IllegalArgumentException("Expecting 1 Id value for " + idName + " but got " + Arrays.toString(ids));
       }
@@ -73,7 +73,7 @@ public final class SimpleExpression extends AbstractValueExpression {
     ElPropertyValue prop = getElProp(request);
     if (prop != null) {
       if (prop.isAssocId()) {
-        Object[] ids = prop.getAssocIdValues((EntityBean) value());
+        Object[] ids = prop.assocIdValues((EntityBean) value());
         if (ids != null) {
           for (Object id : ids) {
             request.addBindValue(id);
@@ -83,7 +83,7 @@ public final class SimpleExpression extends AbstractValueExpression {
       }
       if (prop.isDbEncrypted()) {
         // bind the key as well as the value
-        String encryptKey = prop.getBeanProperty().getEncryptKey().getStringValue();
+        String encryptKey = prop.beanProperty().encryptKey().getStringValue();
         request.addBindEncryptKey(encryptKey);
       } else if (prop.isLocalEncrypted()) {
         Object bindVal = prop.localEncrypt(value());
@@ -101,11 +101,11 @@ public final class SimpleExpression extends AbstractValueExpression {
     ElPropertyValue prop = getElProp(request);
     if (prop != null) {
       if (prop.isAssocId()) {
-        request.append(prop.getAssocIdExpression(propName, type.bind()));
+        request.append(prop.assocIdExpression(propName, type.bind()));
         return;
       }
       if (prop.isDbEncrypted()) {
-        String dsql = prop.getBeanProperty().getDecryptProperty(propName);
+        String dsql = prop.beanProperty().decryptProperty(propName);
         request.append(dsql).append(type.bind());
         return;
       }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBaseContext.java b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBaseContext.java
index 24233cf87..4ab63bec0 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBaseContext.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBaseContext.java
@@ -35,7 +35,7 @@ abstract class DLoadBaseContext {
 
   DLoadBaseContext(DLoadContext parent, BeanDescriptor<?> desc, String path, OrmQueryProperties queryProps) {
     this.parent = parent;
-    this.serverName = parent.getEbeanServer().getName();
+    this.serverName = parent.getEbeanServer().name();
     this.desc = desc;
     this.queryProps = queryProps;
     this.fullPath = parent.getFullPath(path);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBeanContext.java b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBeanContext.java
index ac871e5eb..2dd6c1378 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBeanContext.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBeanContext.java
@@ -39,7 +39,7 @@ final class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContext
 
   @Override
   public void register(BeanPropertyAssocMany<?> many, BeanCollection<?> collection) {
-    String path = fullPath + "." + many.getName();
+    String path = fullPath + "." + many.name();
     parent.register(path, many, collection);
   }
 
@@ -131,7 +131,7 @@ final class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContext
     }
 
     @Override
-    public int getBatchSize() {
+    public int batchSize() {
       return batchSize;
     }
 
@@ -154,7 +154,7 @@ final class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContext
     }
 
     @Override
-    public List<EntityBeanIntercept> getBatch() {
+    public List<EntityBeanIntercept> batch() {
       return list;
     }
 
@@ -164,17 +164,17 @@ final class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContext
     }
 
     @Override
-    public String getFullPath() {
+    public String fullPath() {
       return context.fullPath;
     }
 
     @Override
-    public BeanDescriptor<?> getBeanDescriptor() {
+    public BeanDescriptor<?> descriptor() {
       return context.desc;
     }
 
     @Override
-    public PersistenceContext getPersistenceContext() {
+    public PersistenceContext persistenceContext() {
       return persistenceContext;
     }
 
@@ -203,7 +203,7 @@ final class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContext
       }
 
       LoadBeanRequest req = new LoadBeanRequest(this, ebi, context.hitCache);
-      context.desc.getEbeanServer().loadBean(req);
+      context.desc.ebeanServer().loadBean(req);
       list.clear();
     }
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadContext.java b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadContext.java
index a7ec0e0c8..018a9f647 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadContext.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadContext.java
@@ -67,7 +67,7 @@ public final class DLoadContext implements LoadContext {
   public DLoadContext(BeanDescriptor<?> rootDescriptor, PersistenceContext persistenceContext) {
     this.useDocStore = true;
     this.rootDescriptor = rootDescriptor;
-    this.ebeanServer = rootDescriptor.getEbeanServer();
+    this.ebeanServer = rootDescriptor.ebeanServer();
     this.persistenceContext = persistenceContext;
     this.origin = initOrigin();
     this.defaultBatchSize = 100;
@@ -87,17 +87,17 @@ public final class DLoadContext implements LoadContext {
 
   private ObjectGraphOrigin initOrigin() {
     CallOrigin callOrigin = ebeanServer.createCallOrigin();
-    return new ObjectGraphOrigin(0, callOrigin, rootDescriptor.getFullName());
+    return new ObjectGraphOrigin(0, callOrigin, rootDescriptor.fullName());
   }
 
   public DLoadContext(OrmQueryRequest<?> request, SpiQuerySecondary secondaryQueries) {
-    this.tenantId = request.getTenantId();
-    this.persistenceContext = request.getPersistenceContext();
-    this.ebeanServer = request.getServer();
-    this.defaultBatchSize = request.getLazyLoadBatchSize();
-    this.rootDescriptor = request.getBeanDescriptor();
+    this.tenantId = request.tenantId();
+    this.persistenceContext = request.persistenceContext();
+    this.ebeanServer = request.server();
+    this.defaultBatchSize = request.lazyLoadBatchSize();
+    this.rootDescriptor = request.descriptor();
 
-    SpiQuery<?> query = request.getQuery();
+    SpiQuery<?> query = request.query();
     this.useDocStore = query.isUseDocStore();
     this.asOf = query.getAsOf();
     this.asDraft = query.isAsDraft();
@@ -161,8 +161,8 @@ public final class DLoadContext implements LoadContext {
    * used to build the appropriate query for +query or +lazy loading.
    */
   private void registerSecondaryQuery(OrmQueryProperties props) {
-    ElPropertyValue elGetValue = rootDescriptor.getElGetValue(props.getPath());
-    boolean many = elGetValue.getBeanProperty().containsMany();
+    ElPropertyValue elGetValue = rootDescriptor.elGetValue(props.getPath());
+    boolean many = elGetValue.beanProperty().containsMany();
     registerSecondaryNode(many, props);
   }
 
@@ -295,7 +295,7 @@ public final class DLoadContext implements LoadContext {
   }
 
   DLoadBeanContext getBeanContextWithInherit(String path, BeanPropertyAssocOne<?> property) {
-    String key = path + ":" + property.getTargetDescriptor().getName();
+    String key = path + ":" + property.targetDescriptor().name();
     return beanMap.computeIfAbsent(key, p -> createBeanContext(property, path, null));
   }
 
@@ -323,11 +323,11 @@ public final class DLoadContext implements LoadContext {
 
   private DLoadBeanContext createBeanContext(String path, OrmQueryProperties queryProps) {
     BeanPropertyAssoc<?> p = (BeanPropertyAssoc<?>) getBeanProperty(rootDescriptor, path);
-    return new DLoadBeanContext(this, p.getTargetDescriptor(), path, queryProps);
+    return new DLoadBeanContext(this, p.targetDescriptor(), path, queryProps);
   }
 
   private DLoadBeanContext createBeanContext(BeanPropertyAssoc<?> property, String path, OrmQueryProperties queryProps) {
-    return new DLoadBeanContext(this, property.getTargetDescriptor(), path, queryProps);
+    return new DLoadBeanContext(this, property.targetDescriptor(), path, queryProps);
   }
 
   private BeanProperty getBeanProperty(BeanDescriptor<?> desc, String path) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadManyContext.java b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadManyContext.java
index b830dc96d..8473e148b 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadManyContext.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadManyContext.java
@@ -29,7 +29,7 @@ final class DLoadManyContext extends DLoadBaseContext implements LoadManyContext
   private LoadBuffer currentBuffer;
 
   DLoadManyContext(DLoadContext parent, BeanPropertyAssocMany<?> property, String path, OrmQueryProperties queryProps) {
-    super(parent, property.getBeanDescriptor(), path, queryProps);
+    super(parent, property.descriptor(), path, queryProps);
     this.property = property;
     this.docStoreMapped = property.isTargetDocStoreMapped();
     // bufferList only required when using query joins (queryFetch)
@@ -74,7 +74,7 @@ final class DLoadManyContext extends DLoadBaseContext implements LoadManyContext
 
 
   public String getName() {
-    return parent.getEbeanServer().getName();
+    return parent.getEbeanServer().name();
   }
 
   public void register(BeanCollection<?> bc) {
@@ -177,7 +177,7 @@ final class DLoadManyContext extends DLoadBaseContext implements LoadManyContext
     }
 
     @Override
-    public String getName() {
+    public String name() {
       return context.serverName;
     }
 
@@ -203,7 +203,7 @@ final class DLoadManyContext extends DLoadBaseContext implements LoadManyContext
         boolean useCache = !onlyIds && context.hitCache && context.property.isUseCache();
         if (useCache) {
           EntityBean ownerBean = bc.getOwnerBean();
-          BeanDescriptor<?> parentDesc = context.desc.getBeanDescriptor(ownerBean.getClass());
+          BeanDescriptor<?> parentDesc = context.desc.descriptor(ownerBean.getClass());
           Object parentId = parentDesc.getId(ownerBean);
           if (parentDesc.cacheManyPropLoad(context.property, bc, parentId, context.parent.isReadOnly())) {
             // we loaded the bean collection from cache so remove it from the buffer
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/BatchControl.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/BatchControl.java
index f276bb331..c2a2c834c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/BatchControl.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/BatchControl.java
@@ -181,7 +181,7 @@ public final class BatchControl {
    * Add the request to the batch and return true if we should flush.
    */
   private boolean addToBatch(PersistRequestBean<?> request) {
-    Object alreadyInBatch = persistedBeans.put(request.getEntityBean(), DUMMY);
+    Object alreadyInBatch = persistedBeans.put(request.entityBean(), DUMMY);
     if (alreadyInBatch != null) {
       // special case where the same bean instance has already been
       // added to the batch (doesn't really occur with non-batching
@@ -345,7 +345,7 @@ public final class BatchControl {
   private BatchedBeanHolder getBeanHolder(PersistRequestBean<?> request) {
 
     int depth = transaction.depth();
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
+    BeanDescriptor<?> desc = request.descriptor();
 
     // batching by bean type AND depth
     String key = desc.rootName() + ":" + depth;
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/BatchedBeanHolder.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/BatchedBeanHolder.java
index db6d85a35..fb91333e4 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/BatchedBeanHolder.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/BatchedBeanHolder.java
@@ -57,7 +57,7 @@ final class BatchedBeanHolder {
    */
   BatchedBeanHolder(BatchControl control, BeanDescriptor<?> beanDescriptor, int order) {
     this.control = control;
-    this.shortDesc = beanDescriptor.getName() + ":" + order;
+    this.shortDesc = beanDescriptor.name() + ":" + order;
     this.order = order;
   }
 
@@ -127,7 +127,7 @@ final class BatchedBeanHolder {
   public int append(PersistRequestBean<?> request) {
     empty = false;
     request.setBatched();
-    switch (request.getType()) {
+    switch (request.type()) {
       case INSERT:
         if (inserts == null) {
           inserts = new ArrayList<>();
@@ -151,7 +151,7 @@ final class BatchedBeanHolder {
         return deletes.size();
 
       default:
-        throw new RuntimeException("Invalid type code " + request.getType());
+        throw new RuntimeException("Invalid type code " + request.type());
     }
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/DefaultPersister.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/DefaultPersister.java
index c63b7ed9a..5a8346372 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/DefaultPersister.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/DefaultPersister.java
@@ -73,7 +73,7 @@ public final class DefaultPersister implements Persister {
   public DefaultPersister(SpiEbeanServer server, Binder binder, BeanDescriptorManager descMgr) {
     this.server = server;
     this.beanDescriptorManager = descMgr;
-    this.persistExecute = new DefaultPersistExecute(binder, server.getServerConfig().getPersistBatchSize());
+    this.persistExecute = new DefaultPersistExecute(binder, server.config().getPersistBatchSize());
   }
 
   @Override
@@ -98,7 +98,7 @@ public final class DefaultPersister implements Persister {
 
     SpiUpdate<?> ormUpdate = (SpiUpdate<?>) update;
 
-    BeanManager<?> mgr = beanDescriptorManager.getBeanManager(ormUpdate.getBeanType());
+    BeanManager<?> mgr = beanDescriptorManager.beanManager(ormUpdate.getBeanType());
 
     if (mgr == null) {
       String msg = "No BeanManager found for type [" + ormUpdate.getBeanType() + "]. Is it an entity?";
@@ -150,6 +150,7 @@ public final class DefaultPersister implements Persister {
   /**
    * Add to the flush queue in position 0, 1 or 2.
    */
+  @Override
   public void addToFlushQueue(SpiSqlUpdate update, SpiTransaction t, int pos) {
     new PersistRequestUpdateSql(server, update, t, persistExecute).addToFlushQueue(pos);
   }
@@ -174,30 +175,30 @@ public final class DefaultPersister implements Persister {
   public <T> List<T> draftRestore(Query<T> query, Transaction transaction) {
 
     Class<T> beanType = query.getBeanType();
-    BeanDescriptor<T> desc = server.getBeanDescriptor(beanType);
+    BeanDescriptor<T> desc = server.descriptor(beanType);
 
     DraftHandler<T> draftHandler = new DraftHandler<>(desc, transaction);
 
     List<T> liveBeans = draftHandler.fetchSourceBeans(query, false);
-    PUB.debug("draftRestore [{}] count[{}]", desc.getName(), liveBeans.size());
+    PUB.debug("draftRestore [{}] count[{}]", desc.name(), liveBeans.size());
     if (liveBeans.isEmpty()) {
       return Collections.emptyList();
     }
 
     draftHandler.fetchDestinationBeans(liveBeans, true);
 
-    BeanManager<T> mgr = beanDescriptorManager.getBeanManager(beanType);
+    BeanManager<T> mgr = beanDescriptorManager.beanManager(beanType);
 
     for (T liveBean : liveBeans) {
       T draftBean = draftHandler.publishToDestinationBean(liveBean);
       // reset @DraftDirty and @DraftReset properties
       draftHandler.resetDraft(draftBean);
 
-      PUB.trace("draftRestore bean [{}] id[{}]", desc.getName(), draftHandler.getId());
+      PUB.trace("draftRestore bean [{}] id[{}]", desc.name(), draftHandler.getId());
       update(createRequest(draftBean, transaction, null, mgr, Type.UPDATE, Flags.RECURSE));
     }
 
-    PUB.debug("draftRestore - complete for [{}]", desc.getName());
+    PUB.debug("draftRestore - complete for [{}]", desc.name());
     return draftHandler.getDrafts();
   }
 
@@ -207,7 +208,7 @@ public final class DefaultPersister implements Persister {
   private <T> List<Object> getBeanIds(BeanDescriptor<T> desc, List<T> beans) {
     List<Object> idList = new ArrayList<>(beans.size());
     for (T liveBean : beans) {
-      idList.add(desc.getBeanId(liveBean));
+      idList.add(desc.id(liveBean));
     }
     return idList;
   }
@@ -219,19 +220,19 @@ public final class DefaultPersister implements Persister {
   public <T> List<T> publish(Query<T> query, Transaction transaction) {
 
     Class<T> beanType = query.getBeanType();
-    BeanDescriptor<T> desc = server.getBeanDescriptor(beanType);
+    BeanDescriptor<T> desc = server.descriptor(beanType);
 
     DraftHandler<T> draftHandler = new DraftHandler<>(desc, transaction);
 
     List<T> draftBeans = draftHandler.fetchSourceBeans(query, true);
-    PUB.debug("publish [{}] count[{}]", desc.getName(), draftBeans.size());
+    PUB.debug("publish [{}] count[{}]", desc.name(), draftBeans.size());
     if (draftBeans.isEmpty()) {
       return Collections.emptyList();
     }
 
     draftHandler.fetchDestinationBeans(draftBeans, false);
 
-    BeanManager<T> mgr = beanDescriptorManager.getBeanManager(beanType);
+    BeanManager<T> mgr = beanDescriptorManager.beanManager(beanType);
 
     List<T> livePublish = new ArrayList<>(draftBeans.size());
     for (T draftBean : draftBeans) {
@@ -242,7 +243,7 @@ public final class DefaultPersister implements Persister {
       draftHandler.resetDraft(draftBean);
 
       Type persistType = draftHandler.isInsert() ? Type.INSERT : Type.UPDATE;
-      PUB.trace("publish bean [{}] id[{}] type[{}]", desc.getName(), draftHandler.getId(), persistType);
+      PUB.trace("publish bean [{}] id[{}] type[{}]", desc.name(), draftHandler.getId(), persistType);
 
       PersistRequestBean<T> request = createRequest(liveBean, transaction, null, mgr, persistType, Flags.PUBLISH_RECURSE);
       if (persistType == Type.INSERT) {
@@ -254,7 +255,7 @@ public final class DefaultPersister implements Persister {
 
     draftHandler.updateDrafts(transaction, mgr);
 
-    PUB.debug("publish - complete for [{}]", desc.getName());
+    PUB.debug("publish - complete for [{}]", desc.name());
     return livePublish;
   }
 
@@ -335,7 +336,7 @@ public final class DefaultPersister implements Persister {
 
       List<Object> ids = getBeanIds(desc, sourceBeans);
 
-      Query<T> destQuery = server.find(desc.getBeanType()).where().idIn(ids).query();
+      Query<T> destQuery = server.find(desc.type()).where().idIn(ids).query();
       if (asDraft) {
         destQuery.asDraft();
       }
@@ -347,7 +348,7 @@ public final class DefaultPersister implements Persister {
      * Publish/restore the values from the sourceBean to the matching destination bean.
      */
     T publishToDestinationBean(T sourceBean) {
-      id = desc.getBeanId(sourceBean);
+      id = desc.id(sourceBean);
       T destBean = destBeans.get(id);
       insert = (destBean == null);
       // apply changes from liveBean to draftBean
@@ -537,7 +538,7 @@ public final class DefaultPersister implements Persister {
         request.executeOrQueue();
 
       } else if (logger.isDebugEnabled()) {
-        logger.debug("Update skipped as bean is unchanged: {}", request.getBean());
+        logger.debug("Update skipped as bean is unchanged: {}", request.bean());
       }
 
       if (request.isPersistCascade()) {
@@ -589,7 +590,7 @@ public final class DefaultPersister implements Persister {
       // skip deleting bean. Used where cascade is on
       // both sides of a relationship
       if (logger.isDebugEnabled()) {
-        logger.debug("skipping delete on alreadyRegistered " + req.getBean());
+        logger.debug("skipping delete on alreadyRegistered " + req.bean());
       }
       return 0;
     }
@@ -599,7 +600,7 @@ public final class DefaultPersister implements Persister {
       int rows = delete(req);
       if (draftReq != null) {
         // delete the 'draft' bean ('live' bean deleted first)
-        draftReq.setTrans(req.getTransaction());
+        draftReq.setTrans(req.transaction());
         rows = delete(draftReq);
       }
       req.commitTransIfRequired();
@@ -639,7 +640,7 @@ public final class DefaultPersister implements Persister {
       return 0;
     }
 
-    BeanDescriptor<?> descriptor = beanDescriptorManager.getBeanDescriptor(beanType);
+    BeanDescriptor<?> descriptor = beanDescriptorManager.descriptor(beanType);
     DeleteMode deleteMode = (permanent || !descriptor.isSoftDelete()) ? DeleteMode.HARD : DeleteMode.SOFT;
     if (descriptor.isMultiTenant()) {
       return deleteAsBeans(ids, transaction, deleteMode, descriptor);
@@ -678,7 +679,7 @@ public final class DefaultPersister implements Persister {
    */
   @Override
   public int delete(Class<?> beanType, Object id, Transaction transaction, boolean permanent) {
-    BeanDescriptor<?> descriptor = beanDescriptorManager.getBeanDescriptor(beanType);
+    BeanDescriptor<?> descriptor = beanDescriptorManager.descriptor(beanType);
     if (descriptor.isMultiTenant()) {
       // convert to a delete by bean
       EntityBean bean = descriptor.createEntityBean();
@@ -713,7 +714,7 @@ public final class DefaultPersister implements Persister {
         if (idList != null) {
           q.where().idIn(idList);
           if (t.isLogSummary()) {
-            t.logSummary("-- DeleteById of " + descriptor.getName() + " ids[" + idList + "] requires fetch of foreign key values");
+            t.logSummary("-- DeleteById of " + descriptor.name() + " ids[" + idList + "] requires fetch of foreign key values");
           }
           List<?> beanList = server.findList(q, t);
           deleteList(beanList, t, deleteMode, false);
@@ -722,7 +723,7 @@ public final class DefaultPersister implements Persister {
         } else {
           q.where().idEq(id);
           if (t.isLogSummary()) {
-            t.logSummary("-- DeleteById of " + descriptor.getName() + " id[" + id + "] requires fetch of foreign key values");
+            t.logSummary("-- DeleteById of " + descriptor.name() + " id[" + id + "] requires fetch of foreign key values");
           }
           EntityBean bean = (EntityBean) server.findOne(q, t);
           if (bean == null) {
@@ -738,7 +739,7 @@ public final class DefaultPersister implements Persister {
       // OneToOne exported side with delete cascade
       BeanPropertyAssocOne<?>[] expOnes = descriptor.propertiesOneExportedDelete();
       for (BeanPropertyAssocOne<?> expOne : expOnes) {
-        BeanDescriptor<?> targetDesc = expOne.getTargetDescriptor();
+        BeanDescriptor<?> targetDesc = expOne.targetDescriptor();
         // only cascade soft deletes when supported by target
         if (deleteMode.isHard() || targetDesc.isSoftDelete()) {
           if (deleteMode.isHard() && targetDesc.isDeleteByStatement()) {
@@ -757,7 +758,7 @@ public final class DefaultPersister implements Persister {
       BeanPropertyAssocMany<?>[] manys = descriptor.propertiesManyDelete();
       for (BeanPropertyAssocMany<?> many : manys) {
         if (!many.isManyToMany()) {
-          BeanDescriptor<?> targetDesc = many.getTargetDescriptor();
+          BeanDescriptor<?> targetDesc = many.targetDescriptor();
           // only cascade soft deletes when supported by target
           if (deleteMode.isHard() || targetDesc.isSoftDelete()) {
             if (deleteMode.isHard() && targetDesc.isDeleteByStatement()) {
@@ -782,7 +783,7 @@ public final class DefaultPersister implements Persister {
       for (BeanPropertyAssocMany<?> many : manys) {
         SqlUpdate sqlDelete = many.deleteByParentId(id, idList);
         if (t.isLogSummary()) {
-          t.logSummary("-- Deleting intersection table entries: " + many.getFullBeanName());
+          t.logSummary("-- Deleting intersection table entries: " + many.fullName());
         }
         executeSqlUpdate(sqlDelete, t);
       }
@@ -792,9 +793,9 @@ public final class DefaultPersister implements Persister {
     SqlUpdate deleteById = descriptor.deleteById(id, idList, deleteMode);
     if (t.isLogSummary()) {
       if (idList != null) {
-        t.logSummary("-- Deleting " + descriptor.getName() + " Ids: " + idList);
+        t.logSummary("-- Deleting " + descriptor.name() + " Ids: " + idList);
       } else {
-        t.logSummary("-- Deleting " + descriptor.getName() + " Id: " + id);
+        t.logSummary("-- Deleting " + descriptor.name() + " Id: " + id);
       }
     }
 
@@ -822,9 +823,9 @@ public final class DefaultPersister implements Persister {
 
   private void notifyDeleteById(BeanDescriptor<?> descriptor, Object id, List<Object> idList, Transaction transaction) {
 
-    BeanPersistController controller = descriptor.getPersistController();
+    BeanPersistController controller = descriptor.persistController();
     if (controller != null) {
-      DeleteIdRequest request = new DeleteIdRequest(server, transaction, id);
+      DeleteIdRequest request = new DeleteIdRequest(server, transaction, descriptor.type(), id);
       if (idList == null) {
         controller.preDelete(request);
       } else {
@@ -842,10 +843,10 @@ public final class DefaultPersister implements Persister {
    */
   private Query<?> deleteRequiresQuery(BeanDescriptor<?> desc, BeanPropertyAssocOne<?>[] propImportDelete, DeleteMode deleteMode) {
 
-    Query<?> q = server.createQuery(desc.getBeanType());
+    Query<?> q = server.createQuery(desc.type());
     StringBuilder sb = new StringBuilder(30);
     for (BeanPropertyAssocOne<?> aPropImportDelete : propImportDelete) {
-      sb.append(aPropImportDelete.getName()).append(",");
+      sb.append(aPropImportDelete.name()).append(",");
     }
     q.setAutoTune(false);
     q.select(sb.toString());
@@ -905,13 +906,13 @@ public final class DefaultPersister implements Persister {
    */
   private void saveAssocMany(PersistRequestBean<?> request) {
 
-    EntityBean parentBean = request.getEntityBean();
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
-    SpiTransaction t = request.getTransaction();
+    EntityBean parentBean = request.entityBean();
+    BeanDescriptor<?> desc = request.descriptor();
+    SpiTransaction t = request.transaction();
 
-    EntityBean orphanForRemoval = request.getImportedOrphanForRemoval();
+    EntityBean orphanForRemoval = request.importedOrphanForRemoval();
     if (orphanForRemoval != null) {
-      delete(orphanForRemoval, request.getTransaction(), true);
+      delete(orphanForRemoval, request.transaction(), true);
     }
 
     // exported ones with cascade save
@@ -923,7 +924,7 @@ public final class DefaultPersister implements Persister {
           if (!prop.isSaveRecurseSkippable(detailBean)) {
             t.depth(+1);
             prop.setParentBeanToChild(parentBean, detailBean);
-            saveRecurse(detailBean, t, parentBean, request.getFlags());
+            saveRecurse(detailBean, t, parentBean, request.flags());
             t.depth(-1);
           }
         }
@@ -947,7 +948,7 @@ public final class DefaultPersister implements Persister {
   private SaveManyBase saveManyRequest(boolean insertedParent, BeanPropertyAssocMany<?> many, EntityBean parentBean, PersistRequestBean<?> request) {
     if (!many.isElementCollection()) {
       return new SaveManyBeans(this, insertedParent, many, parentBean, request);
-    } else if (many.getManyType().isMap()) {
+    } else if (many.manyType().isMap()) {
       return new SaveManyElementCollectionMap(this, insertedParent, many, parentBean, request);
     } else {
       return new SaveManyElementCollection(this, insertedParent, many, parentBean, request);
@@ -976,11 +977,11 @@ public final class DefaultPersister implements Persister {
    */
   private void deleteAssocMany(PersistRequestBean<?> request) {
 
-    SpiTransaction t = request.getTransaction();
+    SpiTransaction t = request.transaction();
     t.depth(-1);
 
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
-    EntityBean parentBean = request.getEntityBean();
+    BeanDescriptor<?> desc = request.descriptor();
+    EntityBean parentBean = request.entityBean();
     DeleteMode deleteMode = request.deleteMode();
 
     BeanPropertyAssocOne<?>[] expOnes = desc.propertiesOneExportedDelete();
@@ -1018,7 +1019,7 @@ public final class DefaultPersister implements Persister {
         }
       } else {
 
-        if (ModifyListenMode.REMOVALS == many.getModifyListenMode()) {
+        if (ModifyListenMode.REMOVALS == many.modifyListenMode()) {
           // PrivateOwned ...
           // if soft delete then check target also supports soft delete
           if (deleteMode.isHard() || many.isTargetSoftDelete()) {
@@ -1058,9 +1059,9 @@ public final class DefaultPersister implements Persister {
   void deleteManyDetails(SpiTransaction t, BeanDescriptor<?> desc, EntityBean parentBean,
                          BeanPropertyAssocMany<?> many, List<Object> excludeDetailIds, DeleteMode deleteMode) {
 
-    if (many.getCascadeInfo().isDelete()) {
+    if (many.cascadeInfo().isDelete()) {
       // cascade delete the beans in the collection
-      BeanDescriptor<?> targetDesc = many.getTargetDescriptor();
+      BeanDescriptor<?> targetDesc = many.targetDescriptor();
       if (deleteMode.isHard() || targetDesc.isSoftDelete()) {
         if (targetDesc.isDeleteByStatement()) {
           // Just delete all the children with one statement
@@ -1106,7 +1107,7 @@ public final class DefaultPersister implements Persister {
    */
   private void saveAssocOne(PersistRequestBean<?> request) {
 
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
+    BeanDescriptor<?> desc = request.descriptor();
 
     // imported ones with save cascade
     for (BeanPropertyAssocOne<?> prop : desc.propertiesOneImportedSave()) {
@@ -1116,14 +1117,14 @@ public final class DefaultPersister implements Persister {
       }
 
       if (request.isLoadedProperty(prop)) {
-        EntityBean detailBean = prop.getValueAsEntityBean(request.getEntityBean());
+        EntityBean detailBean = prop.getValueAsEntityBean(request.entityBean());
         if (detailBean != null
           && !prop.isSaveRecurseSkippable(detailBean)
           && !prop.isReference(detailBean)
           && !request.isParent(detailBean)) {
-          SpiTransaction t = request.getTransaction();
+          SpiTransaction t = request.transaction();
           t.depth(-1);
-          saveRecurse(detailBean, t, null, request.getFlags());
+          saveRecurse(detailBean, t, null, request.flags());
           t.depth(+1);
         }
       }
@@ -1139,7 +1140,7 @@ public final class DefaultPersister implements Persister {
   private void deleteOrphan(PersistRequestBean<?> request, BeanPropertyAssocOne<?> prop) {
     Object origValue = request.getOrigValue(prop);
     if (origValue instanceof EntityBean) {
-      delete((EntityBean) origValue, request.getTransaction(), true);
+      delete((EntityBean) origValue, request.transaction(), true);
     }
   }
 
@@ -1151,7 +1152,7 @@ public final class DefaultPersister implements Persister {
 
     DeleteUnloadedForeignKeys fkeys = null;
 
-    for (BeanPropertyAssocOne<?> one : request.getBeanDescriptor().propertiesOneImportedDelete()) {
+    for (BeanPropertyAssocOne<?> one : request.descriptor().propertiesOneImportedDelete()) {
       if (!request.isLoadedProperty(one)) {
         // we have cascade Delete on a partially populated bean and
         // this property was not loaded (so we are going to have to fetch it)
@@ -1172,14 +1173,14 @@ public final class DefaultPersister implements Persister {
 
     DeleteMode deleteMode = request.deleteMode();
 
-    for (BeanPropertyAssocOne<?> prop : request.getBeanDescriptor().propertiesOneImportedDelete()) {
+    for (BeanPropertyAssocOne<?> prop : request.descriptor().propertiesOneImportedDelete()) {
       if (deleteMode.isHard() || prop.isTargetSoftDelete()) {
         if (request.isLoadedProperty(prop)) {
-          Object detailBean = prop.getValue(request.getEntityBean());
+          Object detailBean = prop.getValue(request.entityBean());
           if (detailBean != null) {
             EntityBean detail = (EntityBean) detailBean;
             if (prop.hasId(detail)) {
-              deleteRecurse(detail, request.getTransaction(), deleteMode);
+              deleteRecurse(detail, request.transaction(), deleteMode);
             }
           }
         }
@@ -1273,7 +1274,7 @@ public final class DefaultPersister implements Persister {
    */
   @SuppressWarnings("unchecked")
   private <T> BeanManager<T> getBeanManager(Object bean) {
-    BeanManager<T> mgr = (BeanManager<T>) beanDescriptorManager.getBeanManager(bean.getClass());
+    BeanManager<T> mgr = (BeanManager<T>) beanDescriptorManager.beanManager(bean.getClass());
     if (mgr == null) {
       throw new PersistenceException(errNotRegistered(bean.getClass()));
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/DeleteIdRequest.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/DeleteIdRequest.java
index 760d9eda3..714744d36 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/DeleteIdRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/DeleteIdRequest.java
@@ -9,11 +9,13 @@ final class DeleteIdRequest implements BeanDeleteIdRequest {
 
   private final EbeanServer server;
   private final Transaction transaction;
+  private Class<?> beanType;
   private Object id;
 
-  DeleteIdRequest(SpiEbeanServer server, Transaction transaction, Object id) {
+  DeleteIdRequest(SpiEbeanServer server, Transaction transaction, Class<?> beanType, Object id) {
     this.server = server;
     this.transaction = transaction;
+    this.beanType = beanType;
     this.id = id;
   }
 
@@ -27,12 +29,17 @@ final class DeleteIdRequest implements BeanDeleteIdRequest {
   }
 
   @Override
-  public Transaction getTransaction() {
+  public Transaction transaction() {
     return transaction;
   }
 
   @Override
-  public Object getId() {
+  public Class<?> beanType() {
+    return beanType;
+  }
+
+  @Override
+  public Object id() {
     return id;
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/DeleteUnloadedForeignKeys.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/DeleteUnloadedForeignKeys.java
index 1c258b5bb..ad16a3fa8 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/DeleteUnloadedForeignKeys.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/DeleteUnloadedForeignKeys.java
@@ -49,14 +49,14 @@ final class DeleteUnloadedForeignKeys {
    */
   void queryForeignKeys() {
 
-    BeanDescriptor<?> descriptor = request.getBeanDescriptor();
-    SpiQuery<?> q = (SpiQuery<?>) server.createQuery(descriptor.getBeanType());
+    BeanDescriptor<?> descriptor = request.descriptor();
+    SpiQuery<?> q = (SpiQuery<?>) server.createQuery(descriptor.type());
 
-    Object id = request.getBeanId();
+    Object id = request.beanId();
 
     StringBuilder sb = new StringBuilder(30);
     for (BeanPropertyAssocOne<?> aPropList : propList) {
-      sb.append(aPropList.getName()).append(",");
+      sb.append(aPropList.name()).append(",");
     }
 
     // run query in a separate persistence context
@@ -67,9 +67,9 @@ final class DeleteUnloadedForeignKeys {
     q.setIncludeSoftDeletes();
     q.where().idEq(id);
 
-    SpiTransaction t = request.getTransaction();
+    SpiTransaction t = request.transaction();
     if (t.isLogSummary()) {
-      t.logSummary("-- Ebean fetching foreign key values for delete of " + descriptor.getName() + " id:" + id);
+      t.logSummary("-- Ebean fetching foreign key values for delete of " + descriptor.name() + " id:" + id);
     }
     beanWithForeignKeys = (EntityBean) server.findOne(q, t);
   }
@@ -87,9 +87,9 @@ final class DeleteUnloadedForeignKeys {
         // if bean exists with a unique id then delete it
         if (detailBean != null && prop.hasId((EntityBean) detailBean)) {
           if (deletePermanent) {
-            server.deletePermanent(detailBean, request.getTransaction());
+            server.deletePermanent(detailBean, request.transaction());
           } else {
-            server.delete(detailBean, request.getTransaction());
+            server.delete(detailBean, request.transaction());
           }
         }
       }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeCallableSql.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeCallableSql.java
index fc2c1e0e5..150e02050 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeCallableSql.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeCallableSql.java
@@ -56,15 +56,15 @@ final class ExeCallableSql {
 
   private CallableStatement bindStmt(PersistRequestCallableSql request, boolean batchThisRequest) throws SQLException {
     request.startBind(batchThisRequest);
-    SpiCallableSql callableSql = request.getCallableSql();
-    SpiTransaction t = request.getTransaction();
+    SpiCallableSql callableSql = request.callableSql();
+    SpiTransaction t = request.transaction();
 
     String sql = callableSql.getSql();
     BindParams bindParams = callableSql.getBindParams();
 
     // process named parameters if required
     sql = BindParamsParser.parse(bindParams, sql);
-    boolean logSql = request.isLogSql();
+    boolean logSql = request.logSql();
 
     CallableStatement cstmt;
     if (batchThisRequest) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeOrmUpdate.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeOrmUpdate.java
index ee9ffad23..d6839adca 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeOrmUpdate.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeOrmUpdate.java
@@ -38,7 +38,7 @@ final class ExeOrmUpdate {
         // return -1 to indicate batch mode
         return -1;
       } else {
-        SpiUpdate<?> ormUpdate = request.getOrmUpdate();
+        SpiUpdate<?> ormUpdate = request.ormUpdate();
         if (ormUpdate.getTimeout() > 0) {
           pstmt.setQueryTimeout(ormUpdate.getTimeout());
         }
@@ -49,7 +49,7 @@ final class ExeOrmUpdate {
       }
 
     } catch (SQLException ex) {
-      throw new PersistenceException("Error executing: " + request.getOrmUpdate().getGeneratedSql(), ex);
+      throw new PersistenceException("Error executing: " + request.ormUpdate().getGeneratedSql(), ex);
 
     } finally {
       if (!batchThisRequest) {
@@ -62,14 +62,14 @@ final class ExeOrmUpdate {
    * Convert bean and property names to db table and columns.
    */
   private String translate(PersistRequestOrmUpdate request, String sql) {
-    BeanDescriptor<?> descriptor = request.getBeanDescriptor();
+    BeanDescriptor<?> descriptor = request.descriptor();
     return descriptor.convertOrmUpdateToSql(sql);
   }
 
   private PreparedStatement bindStmt(PersistRequestOrmUpdate request, boolean batchThisRequest) throws SQLException {
     request.startBind(batchThisRequest);
-    SpiUpdate<?> ormUpdate = request.getOrmUpdate();
-    SpiTransaction t = request.getTransaction();
+    SpiUpdate<?> ormUpdate = request.ormUpdate();
+    SpiTransaction t = request.transaction();
 
     String sql = ormUpdate.getUpdateStatement();
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeUpdateSql.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeUpdateSql.java
index 75627671f..2261c81b2 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeUpdateSql.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeUpdateSql.java
@@ -74,8 +74,8 @@ final class ExeUpdateSql {
 
   private PreparedStatement bindStmt(PersistRequestUpdateSql request, boolean batchThisRequest) throws SQLException {
     request.startBind(batchThisRequest);
-    SpiSqlUpdate updateSql = request.getUpdateSql();
-    SpiTransaction t = request.getTransaction();
+    SpiSqlUpdate updateSql = request.updateSql();
+    SpiTransaction t = request.transaction();
 
     BindParams bindParams = updateSql.getBindParams();
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeHandler.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeHandler.java
index 3e09a44f9..d71ed62c8 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeHandler.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeHandler.java
@@ -82,11 +82,11 @@ final class MergeHandler {
    * We use the Id values to determine what are inserts, updates and deletes as part of the merge.
    */
   private EntityBean fetchOutline(Set<String> paths) {
-    Query<?> query = server.find(desc.getBeanType());
+    Query<?> query = server.find(desc.type());
     query.setBeanCacheMode(CacheMode.OFF);
     query.setPersistenceContextScope(PersistenceContextScope.QUERY);
     query.setId(desc.getId(bean));
-    query.select(desc.getIdProperty().getName());
+    query.select(desc.idProperty().name());
 
     for (String path : paths) {
       MergeNode node = buildNode(path);
@@ -126,9 +126,9 @@ final class MergeHandler {
   }
 
   static MergeNode createMergeNode(String fullPath, BeanDescriptor<?> targetDesc, String path) {
-    BeanProperty prop = targetDesc.getBeanProperty(path);
+    BeanProperty prop = targetDesc.beanProperty(path);
     if (!(prop instanceof BeanPropertyAssoc)) {
-      throw new PersistenceException("merge path [" + path + "] is not a ToMany or ToOne property of " + targetDesc.getFullName());
+      throw new PersistenceException("merge path [" + path + "] is not a ToMany or ToOne property of " + targetDesc.fullName());
     }
     if (prop instanceof BeanPropertyAssocMany<?>) {
       BeanPropertyAssocMany<?> assocMany = (BeanPropertyAssocMany<?>) prop;
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNode.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNode.java
index cc5ebeaba..afb94a45c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNode.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNode.java
@@ -22,7 +22,7 @@ abstract class MergeNode {
 
   MergeNode(String fullPath, BeanPropertyAssoc<?> property) {
     this.fullPath = fullPath;
-    this.targetDescriptor = property.getTargetDescriptor();
+    this.targetDescriptor = property.targetDescriptor();
   }
 
   /**
@@ -71,8 +71,8 @@ abstract class MergeNode {
    * Add to the query to fetch the Ids values for the foreign keys basically.
    */
   final void addSelectId(Query<?> query) {
-    BeanProperty idProperty = targetDescriptor.getIdProperty();
-    query.fetch(fullPath, idProperty.getName());
+    BeanProperty idProperty = targetDescriptor.idProperty();
+    query.fetch(fullPath, idProperty.name());
   }
 
   /**
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocManyToMany.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocManyToMany.java
index 02acdf3f9..cd476ae61 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocManyToMany.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocManyToMany.java
@@ -27,8 +27,8 @@ final class MergeNodeAssocManyToMany extends MergeNode {
   @Override
   public void merge(MergeRequest request) {
     EntityBean parentBean = request.getBean();
-    Collection beans = many.getRawCollection(parentBean);
-    Collection outlines = many.getRawCollection(request.getOutline());
+    Collection beans = many.rawCollection(parentBean);
+    Collection outlines = many.rawCollection(request.getOutline());
 
     Map<Object, EntityBean> outlineIds = toMap(outlines);
     List<EntityBean> additions = new ArrayList<>();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocOne.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocOne.java
index 68438bf40..939ace117 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocOne.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocOne.java
@@ -51,10 +51,10 @@ final class MergeNodeAssocOne extends MergeNode {
   private boolean isUpdate(Object beanId, Object outlineId, MergeRequest request) {
     return Objects.equals(beanId, outlineId)
       || !request.isClientGeneratedIds()
-      || request.idExists(targetDescriptor.getBeanType(), beanId);
+      || request.idExists(targetDescriptor.type(), beanId);
   }
 
   private EntityBean getEntityBean(Object bean) {
-    return (EntityBean) one.getVal(bean);
+    return (EntityBean) one.value(bean);
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocOneToMany.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocOneToMany.java
index 8372c955d..3221cc651 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocOneToMany.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/MergeNodeAssocOneToMany.java
@@ -20,8 +20,8 @@ final class MergeNodeAssocOneToMany extends MergeNode {
 
   @Override
   public void merge(MergeRequest request) {
-    Collection beans = many.getRawCollection(request.getBean());
-    Collection outlines = many.getRawCollection(request.getOutline());
+    Collection beans = many.rawCollection(request.getBean());
+    Collection outlines = many.rawCollection(request.getOutline());
 
     Map<Object, EntityBean> outlineIds = toMap(outlines);
     if (beans != null) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyBase.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyBase.java
index a31cee3f2..ceb8f4626 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyBase.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyBase.java
@@ -30,10 +30,10 @@ abstract class SaveManyBase implements SaveMany {
   SaveManyBase(DefaultPersister persister, boolean insertedParent, BeanPropertyAssocMany<?> many, EntityBean parentBean, PersistRequestBean<?> request) {
     this.persister = persister;
     this.request = request;
-    this.server = request.getServer();
+    this.server = request.server();
     this.many = many;
     this.parentBean = parentBean;
-    this.transaction = request.getTransaction();
+    this.transaction = request.transaction();
     this.value = many.getValue(parentBean);
     this.insertedParent = insertedParent;
     if (!insertedParent) {
@@ -49,7 +49,7 @@ abstract class SaveManyBase implements SaveMany {
   final void preElementCollectionUpdate() {
     if (!insertedParent) {
       request.preElementCollectionUpdate();
-      persister.addToFlushQueue(many.deleteByParentId(request.getBeanId(), null), transaction, 1);
+      persister.addToFlushQueue(many.deleteByParentId(request.beanId(), null), transaction, 1);
     }
   }
 
@@ -62,7 +62,7 @@ abstract class SaveManyBase implements SaveMany {
   final void modifyListenReset(BeanCollection<?> c) {
     if (insertedParent) {
       // after insert set the modify listening mode for private owned etc
-      c.setModifyListening(many.getModifyListenMode());
+      c.setModifyListening(many.modifyListenMode());
     }
     c.modifyReset();
   }
@@ -72,7 +72,7 @@ abstract class SaveManyBase implements SaveMany {
       if (request.isNotifyCache()) {
         try {
           String asJson = many.jsonWriteCollection(value);
-          request.addCollectionChange(many.getName(), asJson);
+          request.addCollectionChange(many.name(), asJson);
         } catch (IOException e) {
           log.error("Error build element collection entry for L2 cache", e);
         }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyBeans.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyBeans.java
index f4a70f763..2993bdde1 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyBeans.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyBeans.java
@@ -41,10 +41,10 @@ public final class SaveManyBeans extends SaveManyBase {
 
   SaveManyBeans(DefaultPersister persister, boolean insertedParent, BeanPropertyAssocMany<?> many, EntityBean parentBean, PersistRequestBean<?> request) {
     super(persister, insertedParent, many, parentBean, request);
-    this.cascade = many.getCascadeInfo().isSave();
+    this.cascade = many.cascadeInfo().isSave();
     this.publish = request.isPublish();
-    this.targetDescriptor = many.getTargetDescriptor();
-    this.isMap = many.getManyType().isMap();
+    this.targetDescriptor = many.targetDescriptor();
+    this.isMap = many.manyType().isMap();
     this.saveRecurseSkippable = many.isSaveRecurseSkippable();
     this.deleteMode = targetDescriptor.isSoftDelete() ? DeleteMode.SOFT : DeleteMode.HARD;
     this.untouchedBeanCollection = untouchedBeanCollection();
@@ -95,11 +95,11 @@ public final class SaveManyBeans extends SaveManyBase {
     if (!many.isManyToMany()) {
       return true;
     }
-    return transaction.isSaveAssocManyIntersection(many.getIntersectionTableJoin().getTable(), many.getBeanDescriptor().rootName());
+    return transaction.isSaveAssocManyIntersection(many.intersectionTableJoin().getTable(), many.descriptor().rootName());
   }
 
   private boolean isModifyListenMode() {
-    return BeanCollection.ModifyListenMode.REMOVALS == many.getModifyListenMode();
+    return BeanCollection.ModifyListenMode.REMOVALS == many.modifyListenMode();
   }
 
   /**
@@ -120,7 +120,7 @@ public final class SaveManyBeans extends SaveManyBase {
       if (!insertedParent && canSkipForOrderColumn() && saveRecurseSkippable) {
         return;
       }
-      orderColumn = targetDescriptor.getOrderColumn();
+      orderColumn = targetDescriptor.orderColumn();
     }
 
     if (insertedParent) {
@@ -132,7 +132,7 @@ public final class SaveManyBeans extends SaveManyBase {
       // collect the Id's (to exclude from deleteManyDetails)
       List<Object> detailIds = collectIds(collection, targetDescriptor, isMap);
       // deleting missing children - children not in our collected detailIds
-      persister.deleteManyDetails(transaction, many.getBeanDescriptor(), parentBean, many, detailIds, deleteMode);
+      persister.deleteManyDetails(transaction, many.descriptor(), parentBean, many, detailIds, deleteMode);
     }
 
     transaction.depth(+1);
@@ -186,10 +186,10 @@ public final class SaveManyBeans extends SaveManyBase {
         }
 
         if (!skipSavingThisBean) {
-          persister.saveRecurse(detail, transaction, parentBean, request.getFlags());
+          persister.saveRecurse(detail, transaction, parentBean, request.flags());
           if (many.hasOrderColumn()) {
             // Clear the bean from the PersistenceContext (L1 cache), because the order of referenced beans might have changed
-            final BeanDescriptor<?> beanDescriptor = many.getBeanDescriptor();
+            final BeanDescriptor<?> beanDescriptor = many.descriptor();
             beanDescriptor.contextClear(transaction.getPersistenceContext(), beanDescriptor.getId(parentBean));
           }
         }
@@ -225,7 +225,7 @@ public final class SaveManyBeans extends SaveManyBase {
         detailBean = ((Map.Entry<?, ?>) detailBean).getValue();
       }
       if (detailBean instanceof EntityBean) {
-        Object id = targetDescriptor.getId((EntityBean) detailBean);
+        Object id = targetDescriptor.id(detailBean);
         if (!isNullOrZero(id)) {
           // remember the Id (other details not in the collection) will be removed
           detailIds.add(id);
@@ -277,7 +277,7 @@ public final class SaveManyBeans extends SaveManyBase {
       } else if (value instanceof Collection<?>) {
         additions = (Collection<?>) value;
       } else {
-        throw new PersistenceException("Unhandled ManyToMany type " + value.getClass().getName() + " for " + many.getFullBeanName());
+        throw new PersistenceException("Unhandled ManyToMany type " + value.getClass().getName() + " for " + many.fullName());
       }
       if (!vanillaCollection) {
         BeanCollection<?> manyValue = (BeanCollection<?>) value;
@@ -335,7 +335,7 @@ public final class SaveManyBeans extends SaveManyBase {
   }
 
   private boolean isChangedProperty() {
-    return parentBean._ebean_getIntercept().isChangedProperty(many.getPropertyIndex());
+    return parentBean._ebean_getIntercept().isChangedProperty(many.propertyIndex());
   }
 
   private void removeAssocManyOrphans() {
@@ -344,14 +344,14 @@ public final class SaveManyBeans extends SaveManyBase {
     }
     if (!(value instanceof BeanCollection<?>)) {
       if (!insertedParent && cascade && isChangedProperty()) {
-        persister.addToFlushQueue(many.deleteByParentId(request.getBeanId(), null), transaction, 0);
+        persister.addToFlushQueue(many.deleteByParentId(request.beanId(), null), transaction, 0);
       }
     } else {
       BeanCollection<?> c = (BeanCollection<?>) value;
       Set<?> modifyRemovals = c.getModifyRemovals();
       if (insertedParent) {
         // after insert set the modify listening mode for private owned etc
-        c.setModifyListening(many.getModifyListenMode());
+        c.setModifyListening(many.modifyListenMode());
       }
       // We must not reset when we still have to update other entities in the collection and set their new orderColumn value
       if (!many.hasOrderColumn()) {
@@ -363,7 +363,7 @@ public final class SaveManyBeans extends SaveManyBase {
             EntityBean eb = (EntityBean) removedBean;
             if (eb._ebean_intercept().isOrphanDelete()) {
               // only delete if the bean was loaded meaning that it is known to exist in the DB
-              persister.deleteRequest(persister.createDeleteRemoved(removedBean, transaction, request.getFlags()));
+              persister.deleteRequest(persister.createDeleteRemoved(removedBean, transaction, request.flags()));
             }
           }
         }
@@ -378,7 +378,7 @@ public final class SaveManyBeans extends SaveManyBase {
     BeanCollection.ModifyListenMode mode = manyValue.getModifyListening();
     if (mode == null) {
       // new collection persisted for the first time
-      manyValue.setModifyListening(prop.getModifyListenMode());
+      manyValue.setModifyListening(prop.modifyListenMode());
       return true;
     }
     return false;
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyElementCollection.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyElementCollection.java
index 8b577da93..874505b83 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyElementCollection.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyElementCollection.java
@@ -43,7 +43,7 @@ final class SaveManyElementCollection extends SaveManyBase {
 
   private void saveCollection() {
     SpiSqlUpdate proto = many.insertElementCollection();
-    Object parentId = request.getBeanId();
+    Object parentId = request.beanId();
     for (Object value : collection) {
       final SpiSqlUpdate sqlInsert = proto.copy();
       sqlInsert.setParameter(parentId);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyElementCollectionMap.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyElementCollectionMap.java
index 2941a1499..f57a44d3d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyElementCollectionMap.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyElementCollectionMap.java
@@ -45,7 +45,7 @@ final class SaveManyElementCollectionMap extends SaveManyBase {
 
   private void saveCollection() {
     SpiSqlUpdate proto = many.insertElementCollection();
-    Object parentId = request.getBeanId();
+    Object parentId = request.beanId();
     for (Map.Entry<?, ?> entry : entries) {
       final SpiSqlUpdate sqlInsert = proto.copy();
       sqlInsert.setParameter(parentId);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DeleteHandler.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DeleteHandler.java
index 846e88f80..df23bea16 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DeleteHandler.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DeleteHandler.java
@@ -30,7 +30,7 @@ final class DeleteHandler extends DmlHandler {
   @Override
   public void bind() throws SQLException {
     sql = meta.getSql(persistRequest);
-    SpiTransaction t = persistRequest.getTransaction();
+    SpiTransaction t = persistRequest.transaction();
     PreparedStatement pstmt;
     if (persistRequest.isBatched()) {
       pstmt = getPstmtBatch(t, sql, persistRequest, false);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DeleteMeta.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DeleteMeta.java
index 7baac04ab..6fab530ae 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DeleteMeta.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DeleteMeta.java
@@ -23,11 +23,11 @@ final class DeleteMeta extends BaseMeta {
   DeleteMeta(BeanDescriptor<?> desc, BindableId id, Bindable version, Bindable tenantId) {
     super(id, version, tenantId);
 
-    String tableName = desc.getBaseTable();
+    String tableName = desc.baseTable();
     this.sqlNone = genSql(ConcurrencyMode.NONE, tableName);
     this.sqlVersion = genSql(ConcurrencyMode.VERSION, tableName);
     if (desc.isDraftable()) {
-      String draftTableName = desc.getDraftTable();
+      String draftTableName = desc.draftTable();
       this.sqlDraftNone = genSql(ConcurrencyMode.NONE, draftTableName);
       this.sqlDraftVersion = genSql(ConcurrencyMode.VERSION, draftTableName);
     } else {
@@ -40,13 +40,13 @@ final class DeleteMeta extends BaseMeta {
    * Bind the request based on the concurrency mode.
    */
   public void bind(PersistRequestBean<?> persist, DmlHandler bind) throws SQLException {
-    EntityBean bean = persist.getEntityBean();
+    EntityBean bean = persist.entityBean();
     id.dmlBind(bind, bean);
     if (tenantId != null) {
       tenantId.dmlBind(bind, bean);
     }
 
-    if (persist.getConcurrencyMode() == ConcurrencyMode.VERSION) {
+    if (persist.concurrencyMode() == ConcurrencyMode.VERSION) {
       version.dmlBind(bind, bean);
     }
   }
@@ -56,11 +56,11 @@ final class DeleteMeta extends BaseMeta {
    */
   public String getSql(PersistRequestBean<?> request) {
     if (id.isEmpty()) {
-      throw new IllegalStateException("Can not deleteById on " + request.getFullName() + " as no @Id property");
+      throw new IllegalStateException("Can not deleteById on " + request.fullName() + " as no @Id property");
     }
 
     boolean publish = request.isPublish();
-    switch (request.getConcurrencyMode()) {
+    switch (request.concurrencyMode()) {
       case NONE:
         return publish ? sqlNone : sqlDraftNone;
 
@@ -68,7 +68,7 @@ final class DeleteMeta extends BaseMeta {
         return publish ? sqlVersion : sqlDraftVersion;
 
       default:
-        throw new RuntimeException("Invalid mode " + request.getConcurrencyMode());
+        throw new RuntimeException("Invalid mode " + request.concurrencyMode());
     }
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DmlBeanPersister.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DmlBeanPersister.java
index f9d592cf3..043f210aa 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DmlBeanPersister.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DmlBeanPersister.java
@@ -71,8 +71,8 @@ final class DmlBeanPersister implements BeanPersister {
     } catch (SQLException e) {
       // log the error to the transaction log
       String msg = "Error[" + StringHelper.removeNewLines(e.getMessage()) + "]";
-      if (request.getTransaction().isLogSummary()) {
-        request.getTransaction().logSummary(msg);
+      if (request.transaction().isLogSummary()) {
+        request.transaction().logSummary(msg);
       }
       throw dbPlatform.translate(msg, e);
     } finally {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DmlHandler.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DmlHandler.java
index 3baeb6551..7785223c6 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DmlHandler.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DmlHandler.java
@@ -40,7 +40,7 @@ public abstract class DmlHandler implements PersistHandler, BindableRequest {
   DmlHandler(PersistRequestBean<?> persistRequest) {
     this.now = System.currentTimeMillis();
     this.persistRequest = persistRequest;
-    this.transaction = persistRequest.getTransaction();
+    this.transaction = persistRequest.transaction();
     this.logLevelSql = transaction.isLogSql();
     if (logLevelSql) {
       this.bindLog = new StringBuilder(50);
@@ -68,7 +68,7 @@ public abstract class DmlHandler implements PersistHandler, BindableRequest {
    * Bind to the statement returning the DataBind.
    */
   DataBind bind(PreparedStatement stmt) {
-    return new DataBind(persistRequest.getDataTimeZone(), stmt, transaction.getInternalConnection());
+    return new DataBind(persistRequest.dataTimeZone(), stmt, transaction.getInternalConnection());
   }
 
   /**
@@ -103,7 +103,7 @@ public abstract class DmlHandler implements PersistHandler, BindableRequest {
     } catch (OptimisticLockException e) {
       // add the SQL and bind values to error message
       String m = e.getMessage() + " sql[" + sql + "] bind[" + bindLog + "]";
-      persistRequest.getTransaction().logSummary("OptimisticLockException:" + m);
+      persistRequest.transaction().logSummary("OptimisticLockException:" + m);
       throw new OptimisticLockException(m, null, e.getEntity());
     }
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DocStoreBeanPersister.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DocStoreBeanPersister.java
index 9b9a9c2cf..b805da26e 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DocStoreBeanPersister.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DocStoreBeanPersister.java
@@ -19,13 +19,13 @@ final class DocStoreBeanPersister implements BeanPersister {
   @Override
   public void insert(PersistRequestBean<?> request) throws PersistenceException {
     //request.setIdValueForDocStore();
-    generatedProperties.preInsert(request.getEntityBean(), request.now());
+    generatedProperties.preInsert(request.entityBean(), request.now());
     request.docStorePersist();
   }
 
   @Override
   public void update(PersistRequestBean<?> request) throws PersistenceException {
-    generatedProperties.preUpdate(request.getEntityBean(), request.now());
+    generatedProperties.preUpdate(request.entityBean(), request.now());
     request.docStorePersist();
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/GeneratedProperties.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/GeneratedProperties.java
index 44a1d919b..fad7f8672 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/GeneratedProperties.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/GeneratedProperties.java
@@ -61,7 +61,7 @@ final class GeneratedProperties {
 
     SetValue(BeanProperty property) {
       this.property = property;
-      this.generatedProperty = property.getGeneratedProperty();
+      this.generatedProperty = property.generatedProperty();
     }
 
     void preInsert(EntityBean bean, long now) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/GeneratedPropertyCollector.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/GeneratedPropertyCollector.java
index 33b804a6c..3ca5a567d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/GeneratedPropertyCollector.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/GeneratedPropertyCollector.java
@@ -26,7 +26,7 @@ final class GeneratedPropertyCollector {
   }
 
   private void add(BeanProperty prop) {
-    GeneratedProperty gen = prop.getGeneratedProperty();
+    GeneratedProperty gen = prop.generatedProperty();
     if (gen != null) {
       if (gen.includeInInsert()) {
         preInsert.add(prop);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/InsertHandler.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/InsertHandler.java
index 113e6ff39..3e7ec1cd7 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/InsertHandler.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/InsertHandler.java
@@ -47,8 +47,8 @@ public final class InsertHandler extends DmlHandler {
    */
   @Override
   public void bind() throws SQLException {
-    BeanDescriptor<?> desc = persistRequest.getBeanDescriptor();
-    EntityBean bean = persistRequest.getEntityBean();
+    BeanDescriptor<?> desc = persistRequest.descriptor();
+    EntityBean bean = persistRequest.entityBean();
     Object idValue = desc.getId(bean);
     boolean withId = !isNullOrZero(idValue);
 
@@ -67,7 +67,7 @@ public final class InsertHandler extends DmlHandler {
       }
     }
 
-    SpiTransaction t = persistRequest.getTransaction();
+    SpiTransaction t = persistRequest.transaction();
     // get the appropriate sql
     sql = meta.getSql(withId, persistRequest.isPublish());
     PreparedStatement pstmt;
@@ -148,7 +148,7 @@ public final class InsertHandler extends DmlHandler {
     PreparedStatement stmt = null;
     ResultSet rset = null;
     try {
-      stmt = transaction.getConnection().prepareStatement(persistRequest.getSelectLastInsertedId());
+      stmt = transaction.connection().prepareStatement(persistRequest.getSelectLastInsertedId());
       rset = stmt.executeQuery();
       setGeneratedKey(rset);
     } finally {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/InsertMeta.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/InsertMeta.java
index 588b778e7..64b7d6f3a 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/InsertMeta.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/InsertMeta.java
@@ -48,8 +48,8 @@ final class InsertMeta {
     this.allExcludeDraftOnly = all.excludeDraftOnly();
     this.shadowFKey = shadowFKey;
 
-    String tableName = desc.getBaseTable();
-    String draftTableName = desc.getDraftTable();
+    String tableName = desc.baseTable();
+    String draftTableName = desc.draftTable();
     this.sqlWithId = genSql(false, tableName, false);
     this.sqlDraftWithId = desc.isDraftable() ? genSql(false, draftTableName, true) : sqlWithId;
 
@@ -81,7 +81,7 @@ final class InsertMeta {
   }
 
   private static Bindable getDiscriminator(BeanDescriptor<?> desc) {
-    InheritInfo inheritInfo = desc.getInheritInfo();
+    InheritInfo inheritInfo = desc.inheritInfo();
     return inheritInfo != null ? new BindableDiscriminator(inheritInfo) : null;
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/MetaFactory.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/MetaFactory.java
index 7ad52d87f..9819aaf77 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/MetaFactory.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/MetaFactory.java
@@ -55,7 +55,7 @@ final class MetaFactory {
     embeddedFact.create(setList, desc, DmlMode.UPDATE, includeLobs);
     assocOneFact.create(setList, desc, DmlMode.UPDATE);
 
-    BeanProperty orderColumn = desc.getOrderColumn();
+    BeanProperty orderColumn = desc.orderColumn();
     if (orderColumn != null) {
       setList.add(new BindableOrderColumn(orderColumn));
     }
@@ -89,7 +89,7 @@ final class MetaFactory {
     assocOneFact.create(allList, desc, DmlMode.INSERT);
 
     BindableList allBindable = new BindableList(allList);
-    BeanPropertyAssocOne<?> unidirectional = desc.getUnidirectional();
+    BeanPropertyAssocOne<?> unidirectional = desc.unidirectional();
     Bindable shadowFkey;
     if (unidirectional == null) {
       shadowFkey = null;
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/UpdateHandler.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/UpdateHandler.java
index 49f6e1bfb..01c6e3ce9 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/UpdateHandler.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/UpdateHandler.java
@@ -38,7 +38,7 @@ public final class UpdateHandler extends DmlHandler {
     }
 
     sql = updatePlan.getSql();
-    SpiTransaction t = persistRequest.getTransaction();
+    SpiTransaction t = persistRequest.transaction();
     PreparedStatement pstmt;
     if (persistRequest.isBatched()) {
       pstmt = getPstmtBatch(t, sql, persistRequest, false);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/UpdateMeta.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/UpdateMeta.java
index 4b667e521..79f06940e 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/UpdateMeta.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/UpdateMeta.java
@@ -30,13 +30,13 @@ final class UpdateMeta extends BaseMeta {
    * Bind the request based on the concurrency mode.
    */
   public void bind(PersistRequestBean<?> persist, DmlHandler bind, SpiUpdatePlan updatePlan) throws SQLException {
-    EntityBean bean = persist.getEntityBean();
+    EntityBean bean = persist.entityBean();
     updatePlan.bindSet(bind, bean);
     id.dmlBind(bind, bean);
     if (tenantId != null) {
       tenantId.dmlBind(bind, bean);
     }
-    if (persist.getConcurrencyMode() == ConcurrencyMode.VERSION) {
+    if (persist.concurrencyMode() == ConcurrencyMode.VERSION) {
       version.dmlBind(bind, bean);
     }
   }
@@ -49,10 +49,10 @@ final class UpdateMeta extends BaseMeta {
   }
 
   private SpiUpdatePlan getDynamicUpdatePlan(PersistRequestBean<?> persistRequest) {
-    String key = persistRequest.getUpdatePlanHash();
+    String key = persistRequest.updatePlanHash();
     // check if we can use a cached UpdatePlan
-    BeanDescriptor<?> beanDescriptor = persistRequest.getBeanDescriptor();
-    SpiUpdatePlan updatePlan = beanDescriptor.getUpdatePlan(key);
+    BeanDescriptor<?> beanDescriptor = persistRequest.descriptor();
+    SpiUpdatePlan updatePlan = beanDescriptor.updatePlan(key);
     if (updatePlan != null) {
       return updatePlan;
     }
@@ -64,13 +64,13 @@ final class UpdateMeta extends BaseMeta {
     set.addToUpdate(persistRequest, list);
     BindableList bindableList = new BindableList(list);
 
-    ConcurrencyMode mode = persistRequest.getConcurrencyMode();
+    ConcurrencyMode mode = persistRequest.concurrencyMode();
     // build the SQL for this update statement
-    String sql = genSql(mode, bindableList, persistRequest.getUpdateTable());
+    String sql = genSql(mode, bindableList, persistRequest.updateTable());
 
     updatePlan = new UpdatePlan(key, mode, sql, bindableList);
     // add the UpdatePlan to the cache
-    beanDescriptor.putUpdatePlan(key, updatePlan);
+    beanDescriptor.updatePlan(key, updatePlan);
     return updatePlan;
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableAssocOne.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableAssocOne.java
index 8eaa091a0..bf63accde 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableAssocOne.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableAssocOne.java
@@ -20,7 +20,7 @@ class BindableAssocOne implements Bindable {
 
   BindableAssocOne(BeanPropertyAssocOne<?> assocOne) {
     this.assocOne = assocOne;
-    this.importedId = assocOne.getImportedId();
+    this.importedId = assocOne.importedId();
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableEncryptedProperty.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableEncryptedProperty.java
index 3bfd2fa41..20451be3a 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableEncryptedProperty.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableEncryptedProperty.java
@@ -44,7 +44,7 @@ final class BindableEncryptedProperty implements Bindable {
   public void dmlAppend(GenerateDmlRequest request) {
 
     // columnName = AES_ENCRYPT(?,?)
-    request.appendColumn(prop.getDbColumn(), prop.getDbBind());
+    request.appendColumn(prop.dbColumn(), prop.dbBind());
   }
 
 
@@ -60,17 +60,17 @@ final class BindableEncryptedProperty implements Bindable {
     }
 
     // get Encrypt key
-    String encryptKeyValue = prop.getEncryptKey().getStringValue();
+    String encryptKeyValue = prop.encryptKey().getStringValue();
 
     if (!bindEncryptDataFirst) {
       // H2 encrypt function ... different parameter order
-      request.bindNoLog(encryptKeyValue, Types.VARCHAR, prop.getName() + "=****");
+      request.bindNoLog(encryptKeyValue, Types.VARCHAR, prop.name() + "=****");
     }
     request.bindNoLog(value, prop);
 
     if (bindEncryptDataFirst) {
       // MySql, Postgres, Oracle
-      request.bindNoLog(encryptKeyValue, Types.VARCHAR, prop.getName() + "=****");
+      request.bindNoLog(encryptKeyValue, Types.VARCHAR, prop.name() + "=****");
     }
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableIdEmbedded.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableIdEmbedded.java
index 1f094b0c5..43109f2bd 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableIdEmbedded.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableIdEmbedded.java
@@ -24,7 +24,7 @@ final class BindableIdEmbedded implements BindableId {
 
   BindableIdEmbedded(BeanPropertyAssocOne<?> embId, MatchedImportedProperty[] matches) {
     this.embId = embId;
-    this.props = embId.getProperties();
+    this.props = embId.properties();
     this.matches = matches;
   }
 
@@ -76,7 +76,7 @@ final class BindableIdEmbedded implements BindableId {
   @Override
   public void dmlAppend(GenerateDmlRequest request) {
     for (BeanProperty prop : props) {
-      request.appendColumn(prop.getDbColumn());
+      request.appendColumn(prop.dbColumn());
     }
   }
 
@@ -84,13 +84,13 @@ final class BindableIdEmbedded implements BindableId {
   public boolean deriveConcatenatedId(PersistRequestBean<?> persist) {
 
     if (matches == null) {
-      String m = "No matches for " + embId.getFullBeanName() + " the concatenated key columns where not found?"
+      String m = "No matches for " + embId.fullName() + " the concatenated key columns where not found?"
         + " I expect that the concatenated key was null, and this bean does"
         + " not have ManyToOne assoc beans matching the primary key columns?";
       throw new PersistenceException(m);
     }
 
-    EntityBean bean = persist.getEntityBean();
+    EntityBean bean = persist.entityBean();
 
     // create the new id
     EntityBean newId = (EntityBean) embId.createEmbeddedId();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableIdScalar.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableIdScalar.java
index 518a236b7..7b50e1e4e 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableIdScalar.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableIdScalar.java
@@ -32,7 +32,7 @@ final class BindableIdScalar implements BindableId {
 
   @Override
   public String getIdentityColumn() {
-    return uidProp.getDbColumn();
+    return uidProp.dbColumn();
   }
 
   @Override
@@ -64,7 +64,7 @@ final class BindableIdScalar implements BindableId {
   @Override
   public void dmlAppend(GenerateDmlRequest request) {
 
-    request.appendColumn(uidProp.getDbColumn());
+    request.appendColumn(uidProp.dbColumn());
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableOrderColumn.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableOrderColumn.java
index 7879d192c..7f3e44e0c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableOrderColumn.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableOrderColumn.java
@@ -18,7 +18,7 @@ public final class BindableOrderColumn extends BindableProperty {
 
   @Override
   public void addToUpdate(PersistRequestBean<?> request, List<Bindable> list) {
-    int sortOrder = request.getEntityBeanIntercept().getSortOrder();
+    int sortOrder = request.intercept().getSortOrder();
     if (sortOrder > 0) {
       list.add(this);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableProperty.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableProperty.java
index 8f50fe7b3..d4129922a 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableProperty.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableProperty.java
@@ -38,7 +38,7 @@ class BindableProperty implements Bindable {
 
   @Override
   public final void dmlAppend(GenerateDmlRequest request) {
-    request.appendColumn(prop.getDbColumn());
+    request.appendColumn(prop.dbColumn());
   }
 
   /**
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyJsonInsert.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyJsonInsert.java
index a6d6d6cb6..3014dd36b 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyJsonInsert.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyJsonInsert.java
@@ -15,7 +15,7 @@ final class BindablePropertyJsonInsert extends BindableProperty {
 
   BindablePropertyJsonInsert(BeanProperty prop) {
     super(prop);
-    this.propertyIndex = prop.getPropertyIndex();
+    this.propertyIndex = prop.propertyIndex();
   }
 
   /**
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyJsonUpdate.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyJsonUpdate.java
index 7501fd92b..029e5fcea 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyJsonUpdate.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyJsonUpdate.java
@@ -14,7 +14,7 @@ final class BindablePropertyJsonUpdate extends BindableProperty {
 
   BindablePropertyJsonUpdate(BeanProperty prop) {
     super(prop);
-    this.propertyIndex = prop.getPropertyIndex();
+    this.propertyIndex = prop.propertyIndex();
   }
 
   /**
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyVersion.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyVersion.java
index db28c3035..9c6354e70 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyVersion.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindablePropertyVersion.java
@@ -38,7 +38,7 @@ final class BindablePropertyVersion implements Bindable {
 
   @Override
   public void dmlAppend(GenerateDmlRequest request) {
-    request.appendColumn(prop.getDbColumn());
+    request.appendColumn(prop.dbColumn());
   }
 
   /**
@@ -48,7 +48,7 @@ final class BindablePropertyVersion implements Bindable {
   public void dmlBind(BindableRequest request, EntityBean bean) throws SQLException {
 
     // get prior version value from 'old values'
-    Object value = bean._ebean_getIntercept().getOrigValue(prop.getPropertyIndex());
+    Object value = bean._ebean_getIntercept().getOrigValue(prop.propertyIndex());
     request.bind(value, prop);
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableUnidirectional.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableUnidirectional.java
index 2ea853644..495e89d6b 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableUnidirectional.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableUnidirectional.java
@@ -27,7 +27,7 @@ public final class BindableUnidirectional implements Bindable {
   public BindableUnidirectional(BeanDescriptor<?> desc, BeanPropertyAssocOne<?> unidirectional) {
     this.desc = desc;
     this.unidirectional = unidirectional;
-    this.importedId = unidirectional.getImportedId();
+    this.importedId = unidirectional.importedId();
   }
 
   @Override
@@ -54,10 +54,10 @@ public final class BindableUnidirectional implements Bindable {
   @Override
   public void dmlBind(BindableRequest request, EntityBean bean) throws SQLException {
     PersistRequestBean<?> persistRequest = request.getPersistRequest();
-    Object parentBean = persistRequest.getParentBean();
+    Object parentBean = persistRequest.parentBean();
     if (parentBean == null) {
-      Class<?> localType = desc.getBeanType();
-      Class<?> targetType = unidirectional.getTargetType();
+      Class<?> localType = desc.type();
+      Class<?> targetType = unidirectional.targetType();
 
       String msg = "Error inserting bean [" + localType + "] with unidirectional relationship. ";
       msg += "For inserts you must use cascade save on the master bean [" + targetType + "].";
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryEmbedded.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryEmbedded.java
index cef891682..228fbe9e6 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryEmbedded.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryEmbedded.java
@@ -24,7 +24,7 @@ public final class FactoryEmbedded {
    */
   public void create(List<Bindable> list, BeanDescriptor<?> desc, DmlMode mode, boolean withLobs) {
     for (BeanPropertyAssocOne<?> anEmbedded : desc.propertiesEmbedded()) {
-      BeanProperty[] props = anEmbedded.getProperties();
+      BeanProperty[] props = anEmbedded.properties();
       List<Bindable> bindList = new ArrayList<>(props.length);
       for (BeanProperty prop : props) {
         Bindable item = factoryProperty.create(prop, mode, withLobs, true);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryId.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryId.java
index 398f59ecf..563da85c1 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryId.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryId.java
@@ -13,7 +13,7 @@ public final class FactoryId {
    * Add uniqueId properties.
    */
   public BindableId createId(BeanDescriptor<?> desc) {
-    BeanProperty id = desc.getIdProperty();
+    BeanProperty id = desc.idProperty();
     if (id == null) {
       return new BindableIdEmpty();
     }
@@ -21,7 +21,7 @@ public final class FactoryId {
       return new BindableIdScalar(id);
     } else {
       BeanPropertyAssocOne<?> embId = (BeanPropertyAssocOne<?>) id;
-      MatchedImportedProperty[] matches = MatchedImportedFactory.build(embId.getProperties(), desc);
+      MatchedImportedProperty[] matches = MatchedImportedFactory.build(embId.properties(), desc);
       return new BindableIdEmbedded(embId, matches);
     }
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryVersion.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryVersion.java
index 7c418af31..8474f7f01 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryVersion.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/FactoryVersion.java
@@ -13,7 +13,7 @@ public final class FactoryVersion {
    * Create a Bindable for the version property(s) for a bean type.
    */
   public Bindable create(BeanDescriptor<?> desc) {
-    BeanProperty versionProperty = desc.getVersionProperty();
+    BeanProperty versionProperty = desc.versionProperty();
     return (versionProperty == null) ? null : new BindablePropertyVersion(versionProperty);
   }
 
@@ -21,7 +21,7 @@ public final class FactoryVersion {
    * Create a Bindable for the version property(s) for a bean type.
    */
   public Bindable createForDelete(BeanDescriptor<?> desc) {
-    BeanProperty versionProperty = desc.getVersionProperty();
+    BeanProperty versionProperty = desc.versionProperty();
     return (versionProperty == null) ? null : new BindableProperty(versionProperty);
   }
 
@@ -29,7 +29,7 @@ public final class FactoryVersion {
    * Create a Bindable for TenantId If multi-tenant with partitioning is on this bean type.
    */
   public Bindable createTenantId(BeanDescriptor<?> desc) {
-    BeanProperty tenant = desc.getTenantProperty();
+    BeanProperty tenant = desc.tenantProperty();
     if (tenant == null) {
       return null;
     } else if (tenant instanceof BeanPropertyAssocOne) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/MatchedImportedFactory.java b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/MatchedImportedFactory.java
index e4fa26284..80586ad71 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/MatchedImportedFactory.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/MatchedImportedFactory.java
@@ -24,18 +24,18 @@ final class MatchedImportedFactory {
 
   private static MatchedImportedProperty findMatch(BeanProperty prop, BeanDescriptor<?> desc) {
     // find matching against the local database column
-    String dbColumn = prop.getDbColumn();
+    String dbColumn = prop.dbColumn();
     for (BeanPropertyAssocOne<?> assocOne1 : desc.propertiesOne()) {
       if (assocOne1.isImportedPrimaryKey()) {
         // search using the ImportedId from the assoc one
-        BeanProperty foreignMatch = assocOne1.getImportedId().findMatchImport(dbColumn);
+        BeanProperty foreignMatch = assocOne1.importedId().findMatchImport(dbColumn);
         if (foreignMatch != null) {
           return new MatchedImportedEmbedded(prop, assocOne1, foreignMatch);
         }
       }
     }
     for (BeanProperty beanProperty : desc.propertiesBaseScalar()) {
-      if (dbColumn.equals(beanProperty.getDbColumn())) {
+      if (dbColumn.equals(beanProperty.dbColumn())) {
         return new MatchedImportedScalar(prop, beanProperty);
       }
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/profile/DCountMetric.java b/ebean-core/src/main/java/io/ebeaninternal/server/profile/DCountMetric.java
index 693aa5de8..ba74a5e65 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/profile/DCountMetric.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/profile/DCountMetric.java
@@ -26,6 +26,7 @@ final class DCountMetric implements CountMetric {
     count.add(value);
   }
 
+  @Override
   public void increment() {
     count.increment();
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/profile/DProfileLocation.java b/ebean-core/src/main/java/io/ebeaninternal/server/profile/DProfileLocation.java
index df4c44c56..684cd1a00 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/profile/DProfileLocation.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/profile/DProfileLocation.java
@@ -82,6 +82,7 @@ class DProfileLocation implements ProfileLocation {
     }
   }
 
+  @Override
   public void setTraceCount(int traceCount) {
     this.traceCount = traceCount;
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/profile/DQueryPlanMetric.java b/ebean-core/src/main/java/io/ebeaninternal/server/profile/DQueryPlanMetric.java
index 723c24511..2490db52d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/profile/DQueryPlanMetric.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/profile/DQueryPlanMetric.java
@@ -27,7 +27,7 @@ final class DQueryPlanMetric implements QueryPlanMetric {
   }
 
   @Override
-  public TimedMetric getMetric() {
+  public TimedMetric metric() {
     return metric;
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQuery.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQuery.java
index e9d2281d0..724cd06bb 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQuery.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQuery.java
@@ -184,7 +184,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
     this.request = request;
     this.audit = request.isAuditReads();
     this.queryPlan = queryPlan;
-    this.query = request.getQuery();
+    this.query = request.query();
     this.queryMode = query.getMode();
     this.lazyLoadManyProperty = query.getLazyLoadMany();
     this.readOnly = request.isReadOnly();
@@ -202,7 +202,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
     this.sql = queryPlan.getSql();
     this.rawSql = queryPlan.isRawSql();
     this.logWhereSql = queryPlan.getLogWhereSql();
-    this.desc = request.getBeanDescriptor();
+    this.desc = request.descriptor();
     this.predicates = predicates;
     if (lazyLoadManyProperty != null) {
       this.help = NOOP_ADD;
@@ -216,7 +216,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
     if (request.isFindById()) {
       return null;
     } else {
-      SpiQuery.Type manyType = request.getQuery().getType();
+      SpiQuery.Type manyType = request.query().getType();
       if (manyType == null) {
         // subQuery compiled for InQueryExpression
         return null;
@@ -306,7 +306,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
       // cancelled before we started
       query.checkCancelled();
       startNano = System.nanoTime();
-      SpiTransaction t = request.getTransaction();
+      SpiTransaction t = request.transaction();
       profileOffset = t.profileOffset();
       if (query.isRawSql()) {
         ResultSet suppliedResultSet = query.getRawSql().getResultSet();
@@ -370,7 +370,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
    */
   @Override
   public PersistenceContext getPersistenceContext() {
-    return request.getPersistenceContext();
+    return request.persistenceContext();
   }
 
   @Override
@@ -378,7 +378,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
     if (lazyLoadParentId != null) {
       if (!lazyLoadParentId.equals(this.lazyLoadParentId)) {
         // get the appropriate parent bean from the persistence context
-        this.lazyLoadParentBean = (EntityBean) lazyLoadManyProperty.getBeanDescriptor().contextGet(getPersistenceContext(), lazyLoadParentId);
+        this.lazyLoadParentBean = (EntityBean) lazyLoadManyProperty.descriptor().contextGet(getPersistenceContext(), lazyLoadParentId);
         this.lazyLoadParentId = lazyLoadParentId;
       }
       // add the loadedBean to the appropriate collection of lazyLoadParentBean
@@ -564,7 +564,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
   public void profile() {
     getTransaction()
       .profileStream()
-      .addQueryEvent(query.profileEventId(), profileOffset, desc.getName(), loadedBeanCount, query.getProfileId());
+      .addQueryEvent(query.profileEventId(), profileOffset, desc.name(), loadedBeanCount, query.getProfileId());
   }
 
   QueryIterator<T> readIterate(int bufferSize, OrmQueryRequest<T> request) {
@@ -585,20 +585,20 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
 
   @Override
   public void registerBeanInherit(BeanPropertyAssocOne<?> property, EntityBeanIntercept ebi) {
-    String path = getPath(property.getName());
-    request.getGraphContext().register(path, ebi, property);
+    String path = getPath(property.name());
+    request.loadContext().register(path, ebi, property);
   }
 
   @Override
   public void register(String path, EntityBeanIntercept ebi) {
     path = getPath(path);
-    request.getGraphContext().register(path, ebi);
+    request.loadContext().register(path, ebi);
   }
 
   @Override
   public void register(BeanPropertyAssocMany<?> many, BeanCollection<?> bc) {
-    String path = getPath(many.getName());
-    request.getGraphContext().register(path, many, bc);
+    String path = getPath(many.name());
+    request.loadContext().register(path, many, bc);
   }
 
   /**
@@ -630,14 +630,14 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
   }
 
   public SpiTransaction getTransaction() {
-    return request.getTransaction();
+    return request.transaction();
   }
 
   /**
    * Return the short bean name.
    */
   String getBeanName() {
-    return desc.getName();
+    return desc.name();
   }
 
   /**
@@ -683,7 +683,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
 
   @Override
   public void profileBean(EntityBeanIntercept ebi, String prefix) {
-    ObjectGraphNode node = request.getGraphContext().getObjectGraphNode(prefix);
+    ObjectGraphNode node = request.loadContext().getObjectGraphNode(prefix);
     ebi.setNodeUsageCollector(new NodeUsageCollector(node, profilingListenerRef));
   }
 
@@ -747,7 +747,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
     if (auditIds == null) {
       auditIds = new ArrayList<>(100);
     }
-    auditIds.add(desc.getIdForJson(nextBean));
+    auditIds.add(desc.idForJson(nextBean));
     if (auditFindIterate && auditIds.size() >= 100) {
       auditIterateLogMessage();
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryBuilder.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryBuilder.java
index 09b465893..7aa16981d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryBuilder.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryBuilder.java
@@ -88,12 +88,12 @@ final class CQueryBuilder {
    * Build the delete query.
    */
   <T> CQueryUpdate buildUpdateQuery(boolean deleteRequest, OrmQueryRequest<T> request) {
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
     String rootTableAlias = query.getAlias();
     query.setupForDeleteOrUpdate();
 
     CQueryPredicates predicates = new CQueryPredicates(binder, request);
-    CQueryPlan queryPlan = request.getQueryPlan();
+    CQueryPlan queryPlan = request.queryPlan();
     if (queryPlan != null) {
       // skip building the SqlTree and Sql string
       predicates.prepare(false);
@@ -117,7 +117,7 @@ final class CQueryBuilder {
 
   private <T> String buildDeleteSql(OrmQueryRequest<T> request, String rootTableAlias, CQueryPredicates predicates, SqlTree sqlTree) {
     String alias = alias(rootTableAlias);
-    if (sqlTree.noJoins() && !request.getQuery().hasMaxRowsOrFirstRow()) {
+    if (sqlTree.noJoins() && !request.query().hasMaxRowsOrFirstRow()) {
       if (dbPlatform.isSupportsDeleteTableAlias()) {
         // delete from table <alias> ...
         return aliasReplace(buildSqlDelete("delete", request, predicates, sqlTree).getSql(), alias);
@@ -130,7 +130,7 @@ final class CQueryBuilder {
     }
     // wrap as - delete from table where id in (select id ...)
     String sql = buildSqlDelete(null, request, predicates, sqlTree).getSql();
-    sql = request.getBeanDescriptor().getDeleteByIdInSql() + "in (" + sql + ")";
+    sql = request.descriptor().deleteByIdInSql() + "in (" + sql + ")";
     sql = aliasReplace(sql, alias);
     return sql;
   }
@@ -145,7 +145,7 @@ final class CQueryBuilder {
 
   private <T> String buildUpdateSql(OrmQueryRequest<T> request, String rootTableAlias, CQueryPredicates predicates, SqlTree sqlTree) {
     StringBuilder sb = new StringBuilder(200);
-    sb.append("update ").append(request.getBeanDescriptor().getBaseTable());
+    sb.append("update ").append(request.descriptor().baseTable());
     if (rootTableAlias != null) {
       sb.append(" ").append(rootTableAlias);
     }
@@ -157,7 +157,7 @@ final class CQueryBuilder {
     }
     // wrap as - update table set ... where id in (select id ...)
     String sql = buildSqlUpdate(null, request, predicates, sqlTree).getSql();
-    sql = updateClause + " " + request.getBeanDescriptor().getWhereIdInSql() + "in (" + sql + ")";
+    sql = updateClause + " " + request.descriptor().whereIdInSql() + "in (" + sql + ")";
     sql = aliasReplace(sql, alias(rootTableAlias));
     return sql;
   }
@@ -177,17 +177,17 @@ final class CQueryBuilder {
   }
 
   CQueryFetchSingleAttribute buildFetchAttributeQuery(OrmQueryRequest<?> request) {
-    SpiQuery<?> query = request.getQuery();
+    SpiQuery<?> query = request.query();
     query.setSingleAttribute();
     if (!query.isIncludeSoftDeletes()) {
-      BeanDescriptor<?> desc = request.getBeanDescriptor();
+      BeanDescriptor<?> desc = request.descriptor();
       if (desc.isSoftDelete()) {
-        query.addSoftDeletePredicate(desc.getSoftDeletePredicate(alias(query.getAlias())));
+        query.addSoftDeletePredicate(desc.softDeletePredicate(alias(query.getAlias())));
       }
     }
 
     CQueryPredicates predicates = new CQueryPredicates(binder, request);
-    CQueryPlan queryPlan = request.getQueryPlan();
+    CQueryPlan queryPlan = request.queryPlan();
     if (queryPlan != null) {
       predicates.prepare(false);
       return new CQueryFetchSingleAttribute(request, predicates, queryPlan, query.isCountDistinct());
@@ -208,11 +208,11 @@ final class CQueryBuilder {
    * Build the find ids query.
    */
   <T> CQueryFetchSingleAttribute buildFetchIdsQuery(OrmQueryRequest<T> request) {
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
     query.setSelectId();
-    BeanDescriptor<T> desc = request.getBeanDescriptor();
+    BeanDescriptor<T> desc = request.descriptor();
     if (!query.isIncludeSoftDeletes() && desc.isSoftDelete()) {
-      query.addSoftDeletePredicate(desc.getSoftDeletePredicate(alias(query.getAlias())));
+      query.addSoftDeletePredicate(desc.softDeletePredicate(alias(query.getAlias())));
     }
     return buildFetchAttributeQuery(request);
   }
@@ -235,7 +235,7 @@ final class CQueryBuilder {
    * Build the row count query.
    */
   <T> CQueryRowCount buildRowCountQuery(OrmQueryRequest<T> request) {
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
     // always set the order by to null for row count query
     query.setOrder(null);
     query.setFirstRow(0);
@@ -252,7 +252,7 @@ final class CQueryBuilder {
     }
 
     CQueryPredicates predicates = new CQueryPredicates(binder, request);
-    CQueryPlan queryPlan = request.getQueryPlan();
+    CQueryPlan queryPlan = request.queryPlan();
     if (queryPlan != null) {
       // skip building the SqlTree and Sql string
       predicates.prepare(false);
@@ -304,7 +304,7 @@ final class CQueryBuilder {
    * Return true if the query includes an aggregation property.
    */
   private <T> boolean includesAggregation(OrmQueryRequest<T> request, SpiQuery<T> query) {
-    return request.getBeanDescriptor().includesAggregation(query.getDetail());
+    return request.descriptor().includesAggregation(query.getDetail());
   }
 
   private String wrapSelectCount(String sql) {
@@ -321,7 +321,7 @@ final class CQueryBuilder {
    */
   <T> CQuery<T> buildQuery(OrmQueryRequest<T> request) {
     CQueryPredicates predicates = new CQueryPredicates(binder, request);
-    CQueryPlan queryPlan = request.getQueryPlan();
+    CQueryPlan queryPlan = request.queryPlan();
     if (queryPlan != null) {
       // Reuse the query plan so skip generating SqlTree and SQL.
       // We do prepare and bind the new parameters
@@ -340,7 +340,7 @@ final class CQueryBuilder {
     predicates.prepare(true);
 
     // Build the tree structure that represents the query.
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
 
     SqlTree sqlTree = createSqlTree(request, predicates);
     if (query.isAsOfQuery()) {
@@ -358,10 +358,10 @@ final class CQueryBuilder {
       queryPlan = new CQueryPlan(request, res, sqlTree, false, predicates.getLogWhereSql());
     }
 
-    BeanDescriptor<T> desc = request.getBeanDescriptor();
+    BeanDescriptor<T> desc = request.descriptor();
     if (desc.isReadAuditing()) {
       // log the query plan based bean type (i.e. ignoring query disabling for logging the sql/plan)
-      desc.getReadAuditLogger().queryPlan(new ReadAuditQueryPlan(desc.getFullName(), queryPlan.getAuditQueryKey(), queryPlan.getSql()));
+      desc.readAuditLogger().queryPlan(new ReadAuditQueryPlan(desc.fullName(), queryPlan.getAuditQueryKey(), queryPlan.getSql()));
     }
     // cache the query plan because we can reuse it and also
     // gather query performance statistics based on it.
@@ -401,7 +401,7 @@ final class CQueryBuilder {
    * Create the SqlTree by reading the ResultSetMetaData and mapping table/columns to bean property paths.
    */
   private SqlTree createNativeSqlTree(OrmQueryRequest<?> request, CQueryPredicates predicates) {
-    SpiQuery<?> query = request.getQuery();
+    SpiQuery<?> query = request.query();
     // parse named parameters returning the final sql to execute
     String sql = predicates.parseBindParams(query.getNativeSql());
     if (query.hasMaxRowsOrFirstRow()) {
@@ -409,9 +409,9 @@ final class CQueryBuilder {
     }
     query.setGeneratedSql(sql);
 
-    Connection connection = request.getTransaction().getConnection();
+    Connection connection = request.transaction().connection();
 
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
+    BeanDescriptor<?> desc = request.descriptor();
     try {
       // For SqlServer we need either "selectMethod=cursor" in the connection string or fetch explicitly a cursorable
       // statement here by specifying ResultSet.CONCUR_UPDATABLE
@@ -445,8 +445,8 @@ final class CQueryBuilder {
   }
 
   private SqlTree createRawSqlSqlTree(OrmQueryRequest<?> request, CQueryPredicates predicates) {
-    BeanDescriptor<?> descriptor = request.getBeanDescriptor();
-    ColumnMapping columnMapping = request.getQuery().getRawSql().getColumnMapping();
+    BeanDescriptor<?> descriptor = request.descriptor();
+    ColumnMapping columnMapping = request.query().getRawSql().getColumnMapping();
     PathProperties pathProps = new PathProperties();
 
     // convert list of columns into (tree like) PathProperties
@@ -455,17 +455,17 @@ final class CQueryBuilder {
       SpiRawSql.ColumnMapping.Column column = it.next();
       String propertyName = column.getPropertyName();
       if (!SpiRawSql.IGNORE_COLUMN.equals(propertyName)) {
-        ElPropertyValue el = descriptor.getElGetValue(propertyName);
+        ElPropertyValue el = descriptor.elGetValue(propertyName);
         if (el == null && propertyName.endsWith("Id")) {
           // try default naming convention for foreign key columns
           String foreignIdPath = assocOneIdPath(propertyName);
-          el = descriptor.getElGetValue(foreignIdPath);
+          el = descriptor.elGetValue(foreignIdPath);
           if (el != null) {
             propertyName = foreignIdPath;
           }
         }
         if (el == null) {
-          throw new PersistenceException("Property [" + propertyName + "] not found on " + descriptor.getFullName());
+          throw new PersistenceException("Property [" + propertyName + "] not found on " + descriptor.fullName());
         }
         addRawColumnMapping(pathProps, column, propertyName, el);
       }
@@ -478,8 +478,8 @@ final class CQueryBuilder {
     }
     // check if @Id property included in RawSql
     boolean rawNoId = true;
-    BeanProperty idProperty = descriptor.getIdProperty();
-    if (idProperty != null && columnMapping.contains(idProperty.getName())) {
+    BeanProperty idProperty = descriptor.idProperty();
+    if (idProperty != null && columnMapping.contains(idProperty.name())) {
       // contains the @Id property for the root level bean
       rawNoId = false;
     }
@@ -488,7 +488,7 @@ final class CQueryBuilder {
   }
 
   private void addRawColumnMapping(PathProperties pathProps, Column column, String propertyName, ElPropertyValue el) {
-    BeanProperty beanProperty = el.getBeanProperty();
+    BeanProperty beanProperty = el.beanProperty();
     if (beanProperty.isId()) {
       if (propertyName.contains(".")) {
         // For @Id properties we chop off the last part of the path
@@ -523,7 +523,7 @@ final class CQueryBuilder {
    * Return the SQL response with row limiting (when not an update statement).
    */
   private SqlLimitResponse buildSql(String selectClause, OrmQueryRequest<?> request, CQueryPredicates predicates, SqlTree select) {
-    SpiQuery<?> query = request.getQuery();
+    SpiQuery<?> query = request.query();
     if (query.isNativeSql()) {
       return new SqlLimitResponse(query.getGeneratedSql());
     }
@@ -562,7 +562,7 @@ final class CQueryBuilder {
     private BuildReq(String selectClause, OrmQueryRequest<?> request, CQueryPredicates predicates, SqlTree select, boolean updateStatement) {
       this.selectClause = selectClause;
       this.request = request;
-      this.query = request.getQuery();
+      this.query = request.query();
       this.predicates = predicates;
       this.select = select;
       this.updateStatement = updateStatement;
@@ -583,7 +583,7 @@ final class CQueryBuilder {
           sb.append("r1.attribute_, count(*) from (select ");
           if (distinct) {
             sb.append("distinct t0.");
-            sb.append(request.getBeanDescriptor().getIdProperty().getDbColumn()).append(", ");
+            sb.append(request.descriptor().idProperty().dbColumn()).append(", ");
           }
           sb.append(select.getSelectSql()).append(" as attribute_");
         } else {
@@ -652,7 +652,7 @@ final class CQueryBuilder {
     private void appendHistoryAsOfPredicate() {
       if (query.isAsOfBaseTable() && !historySupport.isStandardsBased()) {
         appendAndOrWhere();
-        sb.append(historySupport.getAsOfPredicate(request.getBaseTableAlias()));
+        sb.append(historySupport.getAsOfPredicate(request.baseTableAlias()));
       }
     }
 
@@ -660,10 +660,10 @@ final class CQueryBuilder {
       if (request.isFindById() || query.getId() != null) {
         appendAndOrWhere();
 
-        BeanDescriptor<?> desc = request.getBeanDescriptor();
-        String idSql = desc.getIdBinderIdSql(query.getAlias());
+        BeanDescriptor<?> desc = request.descriptor();
+        String idSql = desc.idBinderIdSql(query.getAlias());
         if (idSql.isEmpty()) {
-          throw new IllegalStateException("Executing FindById query on entity bean " + desc.getName()
+          throw new IllegalStateException("Executing FindById query on entity bean " + desc.name()
             + " that doesn't have an @Id property??");
         }
         if (updateStatement) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryBuilderRawSql.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryBuilderRawSql.java
index d3b4e7ca6..5c0ccfe3f 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryBuilderRawSql.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryBuilderRawSql.java
@@ -33,7 +33,7 @@ final class CQueryBuilderRawSql {
 
     if (!rsql.isParsed()) {
       String sql = rsql.getUnparsedSql();
-      BindParams bindParams = request.getQuery().getBindParams();
+      BindParams bindParams = request.query().getBindParams();
       if (bindParams != null && bindParams.requiresNamedParamsPrepare()) {
         // convert named parameters into positioned parameters
         sql = BindParamsParser.parse(bindParams, sql);
@@ -46,7 +46,7 @@ final class CQueryBuilderRawSql {
     // build the actual sql String
     String sql = buildMainQuery(orderBy, request, predicates, rsql);
 
-    SpiQuery<?> query = request.getQuery();
+    SpiQuery<?> query = request.query();
     if (query.hasMaxRowsOrFirstRow() && sqlLimiter != null) {
       // wrap with a limit offset or ROW_NUMBER() etc
       return sqlLimiter.limit(new OrmQueryLimitRequest(sql, orderBy, query, dbPlatform, rsql.isDistinct() || query.isDistinct()));
@@ -66,7 +66,7 @@ final class CQueryBuilderRawSql {
     sb.append(" ");
 
     String s = sql.getPreWhere();
-    BindParams bindParams = request.getQuery().getBindParams();
+    BindParams bindParams = request.query().getBindParams();
     if (bindParams != null && bindParams.requiresNamedParamsPrepare()) {
       // convert named parameters into positioned parameters
       // Named Parameters only allowed prior to dynamic where
@@ -77,15 +77,15 @@ final class CQueryBuilderRawSql {
     sb.append(" ");
 
     String dynamicWhere = null;
-    if (request.getQuery().getId() != null) {
+    if (request.query().getId() != null) {
       // need to convert this as well. This avoids the
       // assumption that id has its proper dbColumn assigned
       // which may change if using multiple raw sql statements
       // against the same bean.
-      BeanDescriptor<?> descriptor = request.getBeanDescriptor();
+      BeanDescriptor<?> descriptor = request.descriptor();
       //FIXME: I think this is broken... needs to be logical
       // and then parsed for RawSqlSelect...
-      dynamicWhere = descriptor.getIdBinderIdSql(null);
+      dynamicWhere = descriptor.idBinderIdSql(null);
     }
 
     String dbWhere = predicates.getDbWhere();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryEngine.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryEngine.java
index b76d0b4e9..418354053 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryEngine.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryEngine.java
@@ -79,7 +79,7 @@ public final class CQueryEngine {
   private <T> int executeUpdate(OrmQueryRequest<T> request, CQueryUpdate query) {
     try {
       int rows = query.execute();
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         request.logSql(Str.add(query.getGeneratedSql(), "; --bind(", query.getBindLog(), ") --micros(", query.micros() + ") --rows(", rows + ")"));
       }
       return rows;
@@ -101,17 +101,17 @@ public final class CQueryEngine {
   private <A> List<A> findAttributeList(OrmQueryRequest<?> request, CQueryFetchSingleAttribute rcQuery) {
     try {
       List<A> list = (List<A>) rcQuery.findList();
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logGeneratedSql(request, rcQuery.getGeneratedSql(), rcQuery.getBindLog(), rcQuery.micros());
       }
-      if (request.isLogSummary()) {
-        request.getTransaction().logSummary(rcQuery.getSummary());
+      if (request.logSummary()) {
+        request.transaction().logSummary(rcQuery.getSummary());
       }
       if (request.isQueryCachePut()) {
         request.addDependentTables(rcQuery.getDependentTables());
         list = Collections.unmodifiableList(list);
         request.putToQueryCache(list);
-        if (Boolean.FALSE.equals(request.getQuery().isReadOnly())) {
+        if (Boolean.FALSE.equals(request.query().isReadOnly())) {
           list = new ArrayList<>(list);
         }
       }
@@ -125,14 +125,14 @@ public final class CQueryEngine {
    * Translate the SQLException into a PersistenceException.
    */
   <T> PersistenceException translate(OrmQueryRequest<T> request, String bindLog, String sql, SQLException e) {
-    SpiTransaction t = request.getTransaction();
+    SpiTransaction t = request.transaction();
     if (t.isLogSummary()) {
       // log the error to the transaction log
       String msg = "ERROR executing query, bindLog[" + bindLog + "] error[" + StringHelper.removeNewLines(e.getMessage()) + "]";
       t.logSummary(msg);
     }
     // ensure 'rollback' is logged if queryOnly transaction
-    t.getConnection();
+    t.connection();
     // build a decent error message for the exception
     String m = "Query threw SQLException:" + e.getMessage() + " Bind values:[" + bindLog + "] Query was:" + sql;
     return dbPlatform.translate(m, e);
@@ -159,14 +159,14 @@ public final class CQueryEngine {
     request.setCancelableQuery(rcQuery);
     try {
       int count = rcQuery.findCount();
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logGeneratedSql(request, rcQuery.getGeneratedSql(), rcQuery.getBindLog(), rcQuery.micros());
       }
-      if (request.isLogSummary()) {
-        request.getTransaction().logSummary(rcQuery.getSummary());
+      if (request.logSummary()) {
+        request.transaction().logSummary(rcQuery.getSummary());
       }
-      if (request.getQuery().isFutureFetch()) {
-        request.getTransaction().end();
+      if (request.query().isFutureFetch()) {
+        request.transaction().end();
       }
       if (request.isQueryCachePut()) {
         request.addDependentTables(rcQuery.getDependentTables());
@@ -194,14 +194,14 @@ public final class CQueryEngine {
         logger.trace("Future fetch already cancelled");
         return null;
       }
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logSql(cquery);
       }
       // first check batch sizes set on query joins
-      int iterateBufferSize = request.getSecondaryQueriesMinBatchSize();
+      int iterateBufferSize = request.secondaryQueriesMinBatchSize();
       if (iterateBufferSize < 1) {
         // not set on query joins so check if batch size set on query itself
-        int queryBatch = request.getQuery().getLazyLoadBatchSize();
+        int queryBatch = request.query().getLazyLoadBatchSize();
         if (queryBatch > 0) {
           iterateBufferSize = queryBatch;
         } else {
@@ -210,7 +210,7 @@ public final class CQueryEngine {
       }
 
       QueryIterator<T> readIterate = cquery.readIterate(iterateBufferSize, request);
-      if (request.isLogSummary()) {
+      if (request.logSummary()) {
         logFindManySummary(cquery);
       }
       if (request.isAuditReads()) {
@@ -235,7 +235,7 @@ public final class CQueryEngine {
    * Execute the find versions query returning version beans.
    */
   public <T> List<Version<T>> findVersions(OrmQueryRequest<T> request) {
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
     String sysPeriodLower = getSysPeriodLower(query);
     if (query.isVersionsBetween() && !historySupport.isStandardsBased()) {
       query.where().lt(sysPeriodLower, query.getVersionEnd());
@@ -248,7 +248,7 @@ public final class CQueryEngine {
     request.setCancelableQuery(cquery);
     try {
       cquery.prepareBindExecuteQuery();
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logSql(cquery);
       }
       List<Version<T>> versions = cquery.readVersions();
@@ -256,7 +256,7 @@ public final class CQueryEngine {
       // is not universally supported, not expect huge list here
       versions.sort(OrderVersionDesc.INSTANCE);
       deriveVersionDiffs(versions, request);
-      if (request.isLogSummary()) {
+      if (request.logSummary()) {
         logFindManySummary(cquery);
       }
       if (request.isAuditReads()) {
@@ -274,7 +274,7 @@ public final class CQueryEngine {
   }
 
   private <T> void deriveVersionDiffs(List<Version<T>> versions, OrmQueryRequest<T> request) {
-    BeanDescriptor<T> descriptor = request.getBeanDescriptor();
+    BeanDescriptor<T> descriptor = request.descriptor();
     if (!versions.isEmpty()) {
       Version<T> current = versions.get(0);
       if (versions.size() > 1) {
@@ -324,7 +324,7 @@ public final class CQueryEngine {
         }
       }
       ResultSet resultSet = cquery.prepareResultSet(fwdOnly);
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logSql(cquery);
       }
       return new SpiResultSet(cquery.getPstmt(), resultSet);
@@ -350,11 +350,11 @@ public final class CQueryEngine {
         logger.trace("Future fetch already cancelled");
         return null;
       }
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logSql(cquery);
       }
       BeanCollection<T> beanCollection = cquery.readCollection();
-      if (request.isLogSummary()) {
+      if (request.logSummary()) {
         logFindManySummary(cquery);
       }
       if (request.isAuditReads()) {
@@ -385,13 +385,13 @@ public final class CQueryEngine {
     request.setCancelableQuery(cquery);
     try {
       cquery.prepareBindExecuteQuery();
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logSql(cquery);
       }
       if (cquery.readBean()) {
         bean = cquery.next();
       }
-      if (request.isLogSummary()) {
+      if (request.logSummary()) {
         logFindBeanSummary(cquery);
       }
       if (request.isAuditReads()) {
@@ -417,7 +417,7 @@ public final class CQueryEngine {
    * Log the FindById summary to the transaction log.
    */
   private void logFindBeanSummary(CQuery<?> q) {
-    SpiQuery<?> query = q.getQueryRequest().getQuery();
+    SpiQuery<?> query = q.getQueryRequest().query();
     String loadMode = query.getLoadMode();
     String loadDesc = query.getLoadDescription();
     String lazyLoadProp = query.getLazyLoadProperty();
@@ -460,7 +460,7 @@ public final class CQueryEngine {
    * Log the FindMany to the transaction log.
    */
   private void logFindManySummary(CQuery<?> q) {
-    SpiQuery<?> query = q.getQueryRequest().getQuery();
+    SpiQuery<?> query = q.getQueryRequest().query();
     String loadMode = query.getLoadMode();
     String loadDesc = query.getLoadDescription();
     String lazyLoadProp = query.getLazyLoadProperty();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryFetchSingleAttribute.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryFetchSingleAttribute.java
index 41f9e7f4d..6b19c0aa8 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryFetchSingleAttribute.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryFetchSingleAttribute.java
@@ -50,9 +50,9 @@ final class CQueryFetchSingleAttribute implements SpiProfileTransactionEvent, Ca
   CQueryFetchSingleAttribute(OrmQueryRequest<?> request, CQueryPredicates predicates, CQueryPlan queryPlan, boolean containsCounts) {
     this.request = request;
     this.queryPlan = queryPlan;
-    this.query = request.getQuery();
+    this.query = request.query();
     this.sql = queryPlan.getSql();
-    this.desc = request.getBeanDescriptor();
+    this.desc = request.descriptor();
     this.predicates = predicates;
     this.containsCounts = containsCounts;
     this.reader = queryPlan.getSingleAttributeScalarType();
@@ -66,7 +66,7 @@ final class CQueryFetchSingleAttribute implements SpiProfileTransactionEvent, Ca
     StringBuilder sb = new StringBuilder(80);
     sb.append("FindAttr exeMicros[").append(executionTimeMicros)
       .append("] rows[").append(rowCount)
-      .append("] type[").append(desc.getName())
+      .append("] type[").append(desc.name())
       .append("] predicates[").append(predicates.getLogWhereSql())
       .append("] bind[").append(bindLog).append("]");
     return sb.toString();
@@ -105,7 +105,7 @@ final class CQueryFetchSingleAttribute implements SpiProfileTransactionEvent, Ca
   }
 
   private SpiTransaction getTransaction() {
-    return request.getTransaction();
+    return request.transaction();
   }
 
   /**
@@ -140,7 +140,7 @@ final class CQueryFetchSingleAttribute implements SpiProfileTransactionEvent, Ca
     } finally {
       lock.unlock();
     }
-    dataReader = new RsetDataReader(request.getDataTimeZone(), pstmt.executeQuery());
+    dataReader = new RsetDataReader(request.dataTimeZone(), pstmt.executeQuery());
     query.checkCancelled();
   }
 
@@ -168,7 +168,7 @@ final class CQueryFetchSingleAttribute implements SpiProfileTransactionEvent, Ca
   public void profile() {
     getTransaction()
       .profileStream()
-      .addQueryEvent(query.profileEventId(), profileOffset, desc.getName(), rowCount, query.getProfileId());
+      .addQueryEvent(query.profileEventId(), profileOffset, desc.name(), rowCount, query.getProfileId());
   }
 
   Set<String> getDependentTables() {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryOrderBy.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryOrderBy.java
index ffb65a039..0f369fef8 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryOrderBy.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryOrderBy.java
@@ -54,16 +54,16 @@ final class CQueryOrderBy {
   private String parseProperty(Property p) {
 
     String propName = p.getProperty();
-    ElPropertyValue el = desc.getElGetValue(propName);
+    ElPropertyValue el = desc.elGetValue(propName);
     if (el == null) {
       return p.toStringFormat();
     }
 
-    BeanProperty beanProperty = el.getBeanProperty();
+    BeanProperty beanProperty = el.beanProperty();
     if (beanProperty instanceof BeanPropertyAssoc<?>) {
       BeanPropertyAssoc<?> ap = (BeanPropertyAssoc<?>) beanProperty;
-      IdBinder idBinder = ap.getTargetDescriptor().getIdBinder();
-      return idBinder.getOrderBy(el.getElName(), p.isAscending());
+      IdBinder idBinder = ap.targetDescriptor().idBinder();
+      return idBinder.getOrderBy(el.elName(), p.isAscending());
     }
 
     return p.toStringFormat();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPlan.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPlan.java
index aef2c1164..ccaf22f41 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPlan.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPlan.java
@@ -85,15 +85,15 @@ public class CQueryPlan implements SpiQueryPlan {
    * Create a query plan based on a OrmQueryRequest.
    */
   CQueryPlan(OrmQueryRequest<?> request, SqlLimitResponse sqlRes, SqlTree sqlTree, boolean rawSql, String logWhereSql) {
-    this.server = request.getServer();
-    this.dataTimeZone = server.getDataTimeZone();
-    this.beanType = request.getBeanDescriptor().getBeanType();
-    this.planKey = request.getQueryPlanKey();
-    SpiQuery<?> query = request.getQuery();
+    this.server = request.server();
+    this.dataTimeZone = server.dataTimeZone();
+    this.beanType = request.descriptor().type();
+    this.planKey = request.queryPlanKey();
+    SpiQuery<?> query = request.query();
     this.profileLocation = query.getProfileLocation();
     this.location = (profileLocation == null) ? null : profileLocation.location();
     this.label = query.getPlanLabel();
-    this.name = deriveName(label, query.getType(), request.getBeanDescriptor().getSimpleName());
+    this.name = deriveName(label, query.getType(), request.descriptor().simpleName());
     this.asOfTableCount = query.getAsOfTableCount();
     this.sql = sqlRes.getSql();
     this.sqlTree = sqlTree;
@@ -110,14 +110,14 @@ public class CQueryPlan implements SpiQueryPlan {
    * Create a query plan for a raw sql query.
    */
   CQueryPlan(OrmQueryRequest<?> request, String sql, SqlTree sqlTree, String logWhereSql) {
-    this.server = request.getServer();
-    this.dataTimeZone = server.getDataTimeZone();
-    this.beanType = request.getBeanDescriptor().getBeanType();
-    SpiQuery<?> query = request.getQuery();
+    this.server = request.server();
+    this.dataTimeZone = server.dataTimeZone();
+    this.beanType = request.descriptor().type();
+    SpiQuery<?> query = request.query();
     this.profileLocation = query.getProfileLocation();
     this.location = (profileLocation == null) ? null : profileLocation.location();
     this.label = query.getPlanLabel();
-    this.name = deriveName(label, query.getType(), request.getBeanDescriptor().getSimpleName());
+    this.name = deriveName(label, query.getType(), request.descriptor().simpleName());
     this.planKey = buildPlanKey(sql, logWhereSql);
     this.asOfTableCount = 0;
     this.sql = sql;
@@ -221,7 +221,7 @@ public class CQueryPlan implements SpiQueryPlan {
     DataBind dataBind = new DataBind(dataTimeZone, stmt, conn);
     if (encryptedProps != null) {
       for (STreeProperty encryptedProp : encryptedProps) {
-        dataBind.setString(encryptedProp.getEncryptKeyAsString());
+        dataBind.setString(encryptedProp.encryptKeyAsString());
       }
     }
     return dataBind;
@@ -231,7 +231,7 @@ public class CQueryPlan implements SpiQueryPlan {
     DataBindCapture dataBind = DataBindCapture.of(dataTimeZone);
     if (encryptedProps != null) {
       for (STreeProperty encryptedProp : encryptedProps) {
-        dataBind.setString(encryptedProp.getEncryptKeyAsString());
+        dataBind.setString(encryptedProp.encryptKeyAsString());
       }
     }
     return dataBind;
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPlanRawSql.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPlanRawSql.java
index a23114bf2..f35702ee1 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPlanRawSql.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPlanRawSql.java
@@ -28,7 +28,7 @@ final class CQueryPlanRawSql extends CQueryPlan {
 
   private int[] createIndexPositions(OrmQueryRequest<?> request, SqlTree sqlTree) {
     List<String> chain = sqlTree.buildRawSqlSelectChain();
-    ColumnMapping columnMapping = request.getQuery().getRawSql().getColumnMapping();
+    ColumnMapping columnMapping = request.query().getRawSql().getColumnMapping();
 
     int[] indexPositions = new int[chain.size()];
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPredicates.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPredicates.java
index 94d4800f2..2129141f5 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPredicates.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryPredicates.java
@@ -88,7 +88,7 @@ public final class CQueryPredicates {
   CQueryPredicates(Binder binder, OrmQueryRequest<?> request) {
     this.binder = binder;
     this.request = request;
-    this.query = request.getQuery();
+    this.query = request.query();
     this.bindParams = query.getBindParams();
     this.idValue = query.getId();
   }
@@ -115,7 +115,7 @@ public final class CQueryPredicates {
       dataBind.append(", ");
     }
 
-    CQueryPlan queryPlan = request.getQueryPlan();
+    CQueryPlan queryPlan = request.queryPlan();
     if (queryPlan != null) {
       int asOfTableCount = queryPlan.getAsOfTableCount();
       if (asOfTableCount > 0) {
@@ -132,7 +132,7 @@ public final class CQueryPredicates {
 
     if (idValue != null) {
       // this is a find by id type query...
-      request.getBeanDescriptor().bindId(dataBind, idValue);
+      request.descriptor().bindId(dataBind, idValue);
       dataBind.append(idValue);
       dataBind.append(", ");
     }
@@ -212,7 +212,7 @@ public final class CQueryPredicates {
 
     BeanPropertyAssocMany<?> manyProperty = request.determineMany();
     if (manyProperty != null) {
-      OrmQueryProperties chunk = query.getDetail().getChunk(manyProperty.getName(), false);
+      OrmQueryProperties chunk = query.getDetail().getChunk(manyProperty.name(), false);
       SpiExpressionList<?> filterManyExpr = chunk.getFilterMany();
       if (filterManyExpr != null) {
         this.filterMany = new DefaultExpressionRequest(request, deployParser, binder, filterManyExpr);
@@ -244,7 +244,7 @@ public final class CQueryPredicates {
   private void parsePropertiesToDbColumns(DeployParser deployParser) {
 
     // order by is dependent on the manyProperty (if there is one)
-    String logicalOrderBy = deriveOrderByWithMany(request.getManyProperty());
+    String logicalOrderBy = deriveOrderByWithMany(request.manyProperty());
     if (logicalOrderBy != null) {
       dbOrderBy = deployParser.parse(logicalOrderBy);
     }
@@ -312,7 +312,7 @@ public final class CQueryPredicates {
     if (orderBy == null) {
       return null;
     }
-    return CQueryOrderBy.parse(request.getBeanDescriptor(), orderBy);
+    return CQueryOrderBy.parse(request.descriptor(), orderBy);
   }
 
   /**
@@ -327,17 +327,17 @@ public final class CQueryPredicates {
 
     String orderBy = parseOrderBy();
 
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
-    String orderById = desc.getDefaultOrderBy();
+    BeanDescriptor<?> desc = request.descriptor();
+    String orderById = desc.defaultOrderBy();
 
     if (orderBy == null) {
       orderBy = orderById;
     }
 
     // check for default ordering on the many property...
-    String manyOrderBy = manyProp.getFetchOrderBy();
+    String manyOrderBy = manyProp.fetchOrderBy();
     if (manyOrderBy != null) {
-      orderBy = orderBy + ", " + CQueryBuilder.prefixOrderByFields(manyProp.getName(), manyOrderBy);
+      orderBy = orderBy + ", " + CQueryBuilder.prefixOrderByFields(manyProp.name(), manyOrderBy);
     }
 
     if (request.isFindById()) {
@@ -353,7 +353,7 @@ public final class CQueryPredicates {
     // we need to make sure their is an order by on the
     // top level first (to ensure master/detail construction).
 
-    int manyPos = orderBy.indexOf(manyProp.getName());
+    int manyPos = orderBy.indexOf(manyProp.name());
     int idPos = orderBy.indexOf(" " + orderById);
 
     if (manyPos == -1) {
@@ -370,9 +370,9 @@ public final class CQueryPredicates {
     if (idPos <= -1 || idPos >= manyPos) {
       if (idPos > manyPos) {
         // there was an error with the order by...
-        String msg = "A Query on [" + desc + "] includes a join to a 'many' association [" + manyProp.getName();
+        String msg = "A Query on [" + desc + "] includes a join to a 'many' association [" + manyProp.name();
         msg += "] with an incorrect orderBy [" + orderBy + "]. The id property [" + orderById + "]";
-        msg += " must come before the many property [" + manyProp.getName() + "] in the orderBy.";
+        msg += " must come before the many property [" + manyProp.name() + "] in the orderBy.";
         msg += " Ebean has automatically modified the orderBy clause to do this.";
 
         logger.warn(msg);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryRowCount.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryRowCount.java
index ccfbb3ce6..da7def29b 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryRowCount.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryRowCount.java
@@ -41,9 +41,9 @@ final class CQueryRowCount implements SpiProfileTransactionEvent, CancelableQuer
   CQueryRowCount(CQueryPlan queryPlan, OrmQueryRequest<?> request, CQueryPredicates predicates) {
     this.queryPlan = queryPlan;
     this.request = request;
-    this.query = request.getQuery();
+    this.query = request.query();
     this.sql = queryPlan.getSql();
-    this.desc = request.getBeanDescriptor();
+    this.desc = request.descriptor();
     this.predicates = predicates;
     query.setGeneratedSql(sql);
   }
@@ -56,7 +56,7 @@ final class CQueryRowCount implements SpiProfileTransactionEvent, CancelableQuer
     StringBuilder sb = new StringBuilder(80);
     sb.append("FindCount exeMicros[").append(executionTimeMicros)
       .append("] rows[").append(rowCount)
-      .append("] type[").append(desc.getFullName())
+      .append("] type[").append(desc.fullName())
       .append("] predicates[").append(predicates.getLogWhereSql())
       .append("] bind[").append(bindLog).append("]");
 
@@ -120,7 +120,7 @@ final class CQueryRowCount implements SpiProfileTransactionEvent, CancelableQuer
   }
 
   private SpiTransaction getTransaction() {
-    return request.getTransaction();
+    return request.transaction();
   }
 
   /**
@@ -137,7 +137,7 @@ final class CQueryRowCount implements SpiProfileTransactionEvent, CancelableQuer
   public void profile() {
     getTransaction()
       .profileStream()
-      .addQueryEvent(query.profileEventId(), profileOffset, desc.getName(), rowCount, query.getProfileId());
+      .addQueryEvent(query.profileEventId(), profileOffset, desc.name(), rowCount, query.getProfileId());
   }
 
   Set<String> getDependentTables() {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryUpdate.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryUpdate.java
index e35615a0c..8e7dfd1f5 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryUpdate.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryUpdate.java
@@ -37,9 +37,9 @@ final class CQueryUpdate implements SpiProfileTransactionEvent, CancelableQuery
   CQueryUpdate(OrmQueryRequest<?> request, CQueryPredicates predicates, CQueryPlan queryPlan) {
     this.request = request;
     this.queryPlan = queryPlan;
-    this.query = request.getQuery();
+    this.query = request.query();
     this.sql = queryPlan.getSql();
-    this.desc = request.getBeanDescriptor();
+    this.desc = request.descriptor();
     this.predicates = predicates;
     query.setGeneratedSql(sql);
   }
@@ -98,7 +98,7 @@ final class CQueryUpdate implements SpiProfileTransactionEvent, CancelableQuery
   }
 
   private SpiTransaction getTransaction() {
-    return request.getTransaction();
+    return request.transaction();
   }
 
   /**
@@ -113,7 +113,7 @@ final class CQueryUpdate implements SpiProfileTransactionEvent, CancelableQuery
   public void profile() {
     getTransaction()
       .profileStream()
-      .addQueryEvent(query.profileEventId(), profileOffset, desc.getName(), rowCount, query.getProfileId());
+      .addQueryEvent(query.profileEventId(), profileOffset, desc.name(), rowCount, query.getProfileId());
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultOrmQueryEngine.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultOrmQueryEngine.java
index abab7cdf9..adbeee6d5 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultOrmQueryEngine.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultOrmQueryEngine.java
@@ -53,7 +53,7 @@ public final class DefaultOrmQueryEngine implements OrmQueryEngine {
    */
   private <T> void flushJdbcBatchOnQuery(OrmQueryRequest<T> request) {
 
-    SpiTransaction t = request.getTransaction();
+    SpiTransaction t = request.transaction();
     if (t.isFlushOnQuery()) {
       // before we perform a query, we need to flush any
       // previous persist requests that are queued/batched.
@@ -121,7 +121,7 @@ public final class DefaultOrmQueryEngine implements OrmQueryEngine {
 
     flushJdbcBatchOnQuery(request);
 
-    BeanFindController finder = request.getBeanFinder();
+    BeanFindController finder = request.finder();
 
     BeanCollection<T> result;
     if (finder != null && finder.isInterceptFindMany(request)) {
@@ -131,11 +131,11 @@ public final class DefaultOrmQueryEngine implements OrmQueryEngine {
       result = queryEngine.findMany(request);
     }
 
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
 
-    if (request.isBeanCachePutMany()) {
+    if (result != null && request.isBeanCachePutMany()) {
       // load the individual beans into the bean cache
-      BeanDescriptor<T> descriptor = request.getBeanDescriptor();
+      BeanDescriptor<T> descriptor = request.descriptor();
       Collection<T> c = result.getActualDetails();
       descriptor.cacheBeanPutAll(c);
     }
@@ -162,7 +162,7 @@ public final class DefaultOrmQueryEngine implements OrmQueryEngine {
 
     flushJdbcBatchOnQuery(request);
 
-    BeanFindController finder = request.getBeanFinder();
+    BeanFindController finder = request.finder();
 
     T result;
     if (finder != null && finder.isInterceptFind(request)) {
@@ -172,7 +172,7 @@ public final class DefaultOrmQueryEngine implements OrmQueryEngine {
     }
 
     if (result != null && request.isBeanCachePut()) {
-      request.getBeanDescriptor().cacheBeanPut((EntityBean) result);
+      request.descriptor().cacheBeanPut((EntityBean) result);
     }
 
     return result;
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/STreeProperty.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/STreeProperty.java
index 911f92ef7..954ef6e1c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/STreeProperty.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/STreeProperty.java
@@ -17,12 +17,12 @@ public interface STreeProperty extends ScalarDataReader<Object> {
   /**
    * Return the property name.
    */
-  String getName();
+  String name();
 
   /**
    * Return the full property name (for error messages).
    */
-  String getFullBeanName();
+  String fullName();
 
   /**
    * Return true if the property is the Id.
@@ -54,17 +54,17 @@ public interface STreeProperty extends ScalarDataReader<Object> {
   /**
    * Return the encryption key as a string value (when the property is encrypted).
    */
-  String getEncryptKeyAsString();
+  String encryptKeyAsString();
 
   /**
    * Return the Expression language prefix (join path).
    */
-  String getElPrefix();
+  String elPrefix();
 
   /**
    * Return the underlying scalar type for the property (for findSingleAttribute).
    */
-  ScalarType<?> getScalarType();
+  ScalarType<?> scalarType();
 
   /**
    * For RawSql build the select chain.
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssoc.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssoc.java
index 4f28bf803..06e241f75 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssoc.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssoc.java
@@ -9,7 +9,7 @@ public interface STreePropertyAssoc extends STreeProperty {
   /**
    * Return the extra where clause if set.
    */
-  String getExtraWhere();
+  String extraWhere();
 
   /**
    * Return the type of the target (other side).
@@ -19,7 +19,7 @@ public interface STreePropertyAssoc extends STreeProperty {
   /**
    * Return the IdBinder of the underlying type.
    */
-  IdBinder getIdBinder();
+  IdBinder idBinder();
 
   /**
    * Add a Join with the given alias.
@@ -44,5 +44,5 @@ public interface STreePropertyAssoc extends STreeProperty {
   /**
    * Return the soft delete predicate.
    */
-  String getSoftDeletePredicate(String tableAlias);
+  String softDeletePredicate(String tableAlias);
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssocMany.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssocMany.java
index 63e2b81c0..c827a255e 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssocMany.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssocMany.java
@@ -41,7 +41,7 @@ public interface STreePropertyAssocMany extends STreePropertyAssoc {
   /**
    * Return the intersection table join.
    */
-  TableJoin getIntersectionTableJoin();
+  TableJoin intersectionTableJoin();
 
   /**
    * Add a bean to the collection.
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssocOne.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssocOne.java
index 6e441a617..d7ff3016d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssocOne.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/STreePropertyAssocOne.java
@@ -13,7 +13,7 @@ public interface STreePropertyAssocOne extends STreePropertyAssoc {
   /**
    * Return the scalar type of the associated id property.
    */
-  ScalarDataReader<?> getIdReader();
+  ScalarDataReader<?> idReader();
 
   /**
    * Returns true, if this relation has a foreign key.
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/STreeType.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/STreeType.java
index 8348066ee..3bb58dd1c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/STreeType.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/STreeType.java
@@ -15,7 +15,7 @@ public interface STreeType {
   /**
    * Return the bean short name.
    */
-  String getName();
+  String name();
 
   /**
    * Return true if the underlying type has an Id property.
@@ -40,7 +40,7 @@ public interface STreeType {
   /**
    * Return the soft delete predicate using the given table alias.
    */
-  String getSoftDeletePredicate(String baseTableAlias);
+  String softDeletePredicate(String baseTableAlias);
 
   /**
    * Return the scalar properties.
@@ -65,12 +65,12 @@ public interface STreeType {
   /**
    * Return the inheritance information for this type.
    */
-  InheritInfo getInheritInfo();
+  InheritInfo inheritInfo();
 
   /**
    * Return the IdBinder for this type.
    */
-  IdBinder getIdBinder();
+  IdBinder idBinder();
 
   /**
    * Create a new entity bean instance.
@@ -95,7 +95,7 @@ public interface STreeType {
   /**
    * Return the base table to use given the temporalMode.
    */
-  String getBaseTable(SpiQuery.TemporalMode temporalMode);
+  String baseTable(SpiQuery.TemporalMode temporalMode);
 
   /**
    * Return true if the given path is an embedded bean.
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlBeanLoad.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlBeanLoad.java
index cdeb345c0..27b6d6fbf 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlBeanLoad.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlBeanLoad.java
@@ -50,7 +50,7 @@ public final class SqlBeanLoad {
       return null;
     }
     if ((bean == null)
-      || (lazyLoading && ebi.isLoadedProperty(prop.getPropertyIndex()))
+      || (lazyLoading && ebi.isLoadedProperty(prop.propertyIndex()))
       || (type != null && !prop.isAssignableFrom(type))) {
       // ignore this property
       // ... null: bean already in persistence context
@@ -62,8 +62,8 @@ public final class SqlBeanLoad {
     try {
       return prop.readSet(ctx, bean);
     } catch (Exception e) {
-      bean._ebean_getIntercept().setLoadError(prop.getPropertyIndex(), e);
-      ctx.handleLoadError(prop.getFullBeanName(), e);
+      bean._ebean_getIntercept().setLoadError(prop.propertyIndex(), e);
+      ctx.handleLoadError(prop.fullName(), e);
       return prop.getValue(bean);
     }
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeBuilder.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeBuilder.java
index c3e3fb736..e462313c2 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeBuilder.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeBuilder.java
@@ -59,9 +59,9 @@ public final class SqlTreeBuilder {
    */
   SqlTreeBuilder(OrmQueryRequest<?> request, CQueryPredicates predicates, OrmQueryDetail queryDetail, boolean rawNoId) {
     this.rawSql = true;
-    this.desc = request.getBeanDescriptor();
+    this.desc = request.descriptor();
     this.rawNoId = rawNoId;
-    this.disableLazyLoad = request.getQuery().isDisableLazyLoading();
+    this.disableLazyLoad = request.query().isDisableLazyLoading();
     this.query = null;
     this.subQuery = false;
     this.distinctOnPlatform = false;
@@ -82,8 +82,8 @@ public final class SqlTreeBuilder {
   SqlTreeBuilder(String columnAliasPrefix, CQueryBuilder builder, OrmQueryRequest<?> request, CQueryPredicates predicates) {
     this.rawSql = false;
     this.rawNoId = false;
-    this.desc = request.getBeanDescriptor();
-    this.query = request.getQuery();
+    this.desc = request.descriptor();
+    this.query = request.query();
     this.temporalMode = SpiQuery.TemporalMode.of(query);
     this.disableLazyLoad = query.isDisableLazyLoading();
     this.subQuery = Type.SQ_EXISTS == query.getType()
@@ -95,7 +95,7 @@ public final class SqlTreeBuilder {
     this.manyWhereJoins = query.getManyWhereJoins();
     this.queryDetail = query.getDetail();
     this.predicates = predicates;
-    this.alias = new SqlTreeAlias(request.getBaseTableAlias(), temporalMode);
+    this.alias = new SqlTreeAlias(request.baseTableAlias(), temporalMode);
     this.distinctOnPlatform = builder.isPlatformDistinctOn();
     String fromForUpdate = builder.fromForUpdate(query);
     CQueryHistorySupport historySupport = builder.getHistorySupport(query);
@@ -226,7 +226,7 @@ public final class SqlTreeBuilder {
     List<SqlTreeNode> myJoinList = new ArrayList<>();
     List<STreePropertyAssocOne> extraProps = new ArrayList<>();
     for (STreePropertyAssocOne one : desc.propsOne()) {
-      String propPrefix = SplitName.add(prefix, one.getName());
+      String propPrefix = SplitName.add(prefix, one.name());
       if (isIncludeBean(propPrefix)) {
         selectIncludes.add(propPrefix);
         if (!one.hasForeignKey()) {
@@ -237,7 +237,7 @@ public final class SqlTreeBuilder {
     }
 
     for (STreePropertyAssocMany many : desc.propsMany()) {
-      String propPrefix = SplitName.add(prefix, many.getName());
+      String propPrefix = SplitName.add(prefix, many.name());
       if (isIncludeMany(propPrefix, many)) {
         selectIncludes.add(propPrefix);
         buildSelectChain(propPrefix, many, many.target(), myJoinList);
@@ -294,7 +294,7 @@ public final class SqlTreeBuilder {
 
       String baseTable = (query == null) ? null : query.getBaseTable();
       if (baseTable == null) {
-        baseTable = desc.getBaseTable(temporalMode);
+        baseTable = desc.baseTable(temporalMode);
       }
       return new SqlTreeNodeRoot(desc, props, myList, withId, includeJoin, lazyLoadMany, temporalMode, disableLazyLoad, sqlDistinct, baseTable);
 
@@ -413,11 +413,11 @@ public final class SqlTreeBuilder {
           } else {
             logger.error("property [" + propName + "] not found on " + desc + " for query - excluding it.");
           }
-        } else if (p.isEmbedded() || (p instanceof STreePropertyAssoc && !queryProps.isIncludedBeanJoin(p.getName()))) {
+        } else if (p.isEmbedded() || (p instanceof STreePropertyAssoc && !queryProps.isIncludedBeanJoin(p.name()))) {
           // add the embedded bean or the *ToOne assoc bean.  We skip the check that the *ToOne propName maps to Id property ...
           selectProps.add(p);
         } else {
-          logger.error("property [" + p.getFullBeanName() + "] expected to be an embedded or *ToOne bean for query - excluding it.");
+          logger.error("property [" + p.fullName() + "] expected to be an embedded or *ToOne bean for query - excluding it.");
         }
       }
 
@@ -440,7 +440,7 @@ public final class SqlTreeBuilder {
         // included as a bean join. With a bean join
         // the property should be excluded as the bean
         // join has its own node in the SqlTree.
-        if (!queryProps.isIncludedBeanJoin(p.getName())) {
+        if (!queryProps.isIncludedBeanJoin(p.name())) {
           // include the property... which basically
           // means include the foreign key column(s)
           selectProps.add(p);
@@ -497,7 +497,7 @@ public final class SqlTreeBuilder {
     for (STreePropertyAssocOne propertyAssocOne : desc.propsOne()) {
       //noinspection StatementWithEmptyBody
       if (queryProps != null
-        && queryProps.isIncludedBeanJoin(propertyAssocOne.getName())
+        && queryProps.isIncludedBeanJoin(propertyAssocOne.name())
         && propertyAssocOne.hasForeignKey()
         && !propertyAssocOne.isFormula()) {
         // if it is a joined bean with FK constraint... then don't add the property
@@ -507,7 +507,7 @@ public final class SqlTreeBuilder {
       }
     }
 
-    InheritInfo inheritInfo = desc.getInheritInfo();
+    InheritInfo inheritInfo = desc.inheritInfo();
     if (inheritInfo != null) {
       // add sub type properties
       inheritInfo.addChildrenProperties(selectProps);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeBean.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeBean.java
index 83c8362a9..82ae6654f 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeBean.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeBean.java
@@ -87,15 +87,15 @@ class SqlTreeNodeBean implements SqlTreeNode {
                           List<SqlTreeNode> myChildren, boolean withId, STreePropertyAssocMany lazyLoadParent,
                           SpiQuery.TemporalMode temporalMode, boolean disableLazyLoad) {
     this.lazyLoadParent = lazyLoadParent;
-    this.lazyLoadParentIdBinder = (lazyLoadParent == null) ? null : lazyLoadParent.getIdBinder();
+    this.lazyLoadParentIdBinder = (lazyLoadParent == null) ? null : lazyLoadParent.idBinder();
     this.prefix = prefix;
     this.desc = desc;
-    this.inheritInfo = desc.getInheritInfo();
-    this.idBinder = desc.getIdBinder();
+    this.inheritInfo = desc.inheritInfo();
+    this.idBinder = desc.idBinder();
     this.temporalMode = temporalMode;
     this.temporalVersions = temporalMode == SpiQuery.TemporalMode.VERSIONS;
     this.nodeBeanProp = beanProp;
-    this.extraWhere = (beanProp == null) ? null : beanProp.getExtraWhere();
+    this.extraWhere = (beanProp == null) ? null : beanProp.extraWhere();
     this.aggregation = props.isAggregation();
     boolean aggregationRoot = props.isAggregationRoot();
     // the bean has an Id property and we want to use it
@@ -123,14 +123,14 @@ class SqlTreeNodeBean implements SqlTreeNode {
       // if we have no property ask first children (in a distinct select with join)
       if (children.length == 0) {
         // expected to be a findIds query
-        return desc.getIdBinder().getBeanProperty();
+        return desc.idBinder().getBeanProperty();
       }
       return children[0].getSingleAttributeReader();
     }
     if (properties[0] instanceof STreePropertyAssocOne) {
       STreePropertyAssocOne assocOne = (STreePropertyAssocOne)properties[0];
       if (assocOne.isAssocId()) {
-        return assocOne.getIdReader();
+        return assocOne.idReader();
       }
     }
     return properties[0];
@@ -139,7 +139,7 @@ class SqlTreeNodeBean implements SqlTreeNode {
   private Map<String, String> createPathMap(String prefix, STreeType desc) {
     HashMap<String, String> m = new HashMap<>();
     for (STreePropertyAssocMany many : desc.propsMany()) {
-      String name = many.getName();
+      String name = many.name();
       m.put(name, getPath(prefix, name));
     }
     return m;
@@ -184,7 +184,7 @@ class SqlTreeNodeBean implements SqlTreeNode {
 
     @Override
     void initBeanType() throws SQLException {
-      InheritInfo localInfo = readId ? inheritInfo.readType(ctx) : desc.getInheritInfo();
+      InheritInfo localInfo = readId ? inheritInfo.readType(ctx) : desc.inheritInfo();
       if (localInfo == null) {
         // the bean must be null
         localIdBinder = idBinder;
@@ -602,7 +602,7 @@ class SqlTreeNodeBean implements SqlTreeNode {
   @Override
   public final void addSoftDeletePredicate(SpiQuery<?> query) {
     if (desc.isSoftDelete()) {
-      query.addSoftDeletePredicate(desc.getSoftDeletePredicate(baseTableAlias));
+      query.addSoftDeletePredicate(desc.softDeletePredicate(baseTableAlias));
     }
   }
 
@@ -626,7 +626,7 @@ class SqlTreeNodeBean implements SqlTreeNode {
 
   @Override
   public void dependentTables(Set<String> tables) {
-    tables.add(nodeBeanProp.target().getBaseTable(temporalMode));
+    tables.add(nodeBeanProp.target().baseTable(temporalMode));
     for (SqlTreeNode child : children) {
       child.dependentTables(tables);
     }
@@ -642,7 +642,7 @@ class SqlTreeNodeBean implements SqlTreeNode {
        appendJoinDiscriminator(ctx);
     }
     if (desc.isSoftDelete() && temporalMode != SpiQuery.TemporalMode.SOFT_DELETED) {
-      ctx.append(" and ").append(desc.getSoftDeletePredicate(ctx.getTableAlias(prefix)));
+      ctx.append(" and ").append(desc.softDeletePredicate(ctx.getTableAlias(prefix)));
     }
     return sqlJoinType;
   }
@@ -658,7 +658,7 @@ class SqlTreeNodeBean implements SqlTreeNode {
         String alias2 = alias + "z_";
 
         // adding the additional join to the intersection table
-        TableJoin manyToManyJoin = manyProp.getIntersectionTableJoin();
+        TableJoin manyToManyJoin = manyProp.intersectionTableJoin();
         manyToManyJoin.addJoin(joinType, parentAlias, alias2, ctx);
         if (!manyProp.isExcludedFromHistory()) {
           intersectionAsOfTableAlias = true;
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeExtraJoin.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeExtraJoin.java
index ae5e5bf3f..35bd5adae 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeExtraJoin.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeExtraJoin.java
@@ -101,7 +101,7 @@ final class SqlTreeNodeExtraJoin implements SqlTreeNode {
 
   @Override
   public void dependentTables(Set<String> tables) {
-    tables.add(assocBeanProperty.target().getBaseTable(SpiQuery.TemporalMode.CURRENT));
+    tables.add(assocBeanProperty.target().baseTable(SpiQuery.TemporalMode.CURRENT));
     if (children != null) {
       for (SqlTreeNode child : children) {
         child.dependentTables(tables);
@@ -123,7 +123,7 @@ final class SqlTreeNodeExtraJoin implements SqlTreeNode {
         String parentAlias = ctx.getTableAlias(split[0]);
         String alias2 = alias + "z_";
 
-        TableJoin manyToManyJoin = manyProp.getIntersectionTableJoin();
+        TableJoin manyToManyJoin = manyProp.intersectionTableJoin();
         manyToManyJoin.addJoin(joinType, parentAlias, alias2, ctx);
 
         assocBeanProperty.addJoin(joinType, alias2, alias, ctx);
@@ -149,7 +149,7 @@ final class SqlTreeNodeExtraJoin implements SqlTreeNode {
       }
       joinType = assocBeanProperty.addJoin(joinType, prefix, ctx);
       if (!oneToOneExported && assocBeanProperty.isTargetSoftDelete() && temporalMode != SpiQuery.TemporalMode.SOFT_DELETED) {
-        ctx.append(" and ").append(assocBeanProperty.getSoftDeletePredicate(ctx.getTableAlias(prefix)));
+        ctx.append(" and ").append(assocBeanProperty.softDeletePredicate(ctx.getTableAlias(prefix)));
       }
     }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeManyWhereJoin.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeManyWhereJoin.java
index c3f534a25..73c7a18b2 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeManyWhereJoin.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeNodeManyWhereJoin.java
@@ -94,18 +94,18 @@ final class SqlTreeNodeManyWhereJoin implements SqlTreeNode {
     if (nodeBeanProp instanceof STreePropertyAssocOne) {
       nodeBeanProp.addJoin(joinType, parentAlias, alias, ctx);
       if (softDelete) {
-        ctx.append(" and ").append(target.getSoftDeletePredicate(alias));
+        ctx.append(" and ").append(target.softDeletePredicate(alias));
       }
     } else {
       STreePropertyAssocMany manyProp = (STreePropertyAssocMany) nodeBeanProp;
       if (!manyProp.hasJoinTable()) {
         manyProp.addJoin(joinType, parentAlias, alias, ctx);
         if (softDelete) {
-          ctx.append(" and ").append(target.getSoftDeletePredicate(alias));
+          ctx.append(" and ").append(target.softDeletePredicate(alias));
         }
       } else {
         String alias2 = alias + "z_";
-        TableJoin manyToManyJoin = manyProp.getIntersectionTableJoin();
+        TableJoin manyToManyJoin = manyProp.intersectionTableJoin();
         manyToManyJoin.addJoin(joinType, parentAlias, alias2, ctx);
         manyProp.addJoin(joinType, alias2, alias, ctx);
       }
@@ -114,7 +114,7 @@ final class SqlTreeNodeManyWhereJoin implements SqlTreeNode {
 
   @Override
   public void dependentTables(Set<String> tables) {
-    tables.add(nodeBeanProp.target().getBaseTable(SpiQuery.TemporalMode.CURRENT));
+    tables.add(nodeBeanProp.target().baseTable(SpiQuery.TemporalMode.CURRENT));
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeProperties.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeProperties.java
index 489341789..623b1dd36 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeProperties.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/SqlTreeProperties.java
@@ -35,11 +35,11 @@ public final class SqlTreeProperties {
 
   public void add(STreeProperty prop) {
     propsList.add(prop);
-    propNames.add(prop.getName());
+    propNames.add(prop.name());
     if (prop.isAggregation()) {
       if (!aggregation) {
         aggregation = true;
-        aggregationPath = prop.getElPrefix();
+        aggregationPath = prop.elPrefix();
       }
       if (prop.isAggregationManyToOne()) {
         aggregationManyToOne = true;
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java b/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java
index 65ba6b9a3..ccd17b9ce 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java
@@ -165,10 +165,10 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
   public DefaultOrmQuery(BeanDescriptor<T> desc, SpiEbeanServer server, ExpressionFactory expressionFactory) {
     this.beanDescriptor = desc;
     this.rootBeanDescriptor = desc;
-    this.beanType = desc.getBeanType();
+    this.beanType = desc.type();
     this.server = server;
-    this.orderById = server.getServerConfig().isDefaultOrderById();
-    this.disableLazyLoading = server.getServerConfig().isDisableLazyLoading();
+    this.orderById = server.config().isDefaultOrderById();
+    this.disableLazyLoading = server.config().isDisableLazyLoading();
     this.expressionFactory = expressionFactory;
     this.detail = new OrmQueryDetail();
   }
@@ -201,7 +201,7 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
   @Override
   public boolean isFindById() {
     if (id == null && whereExpressions != null) {
-      id = whereExpressions.idEqualTo(beanDescriptor.getIdName());
+      id = whereExpressions.idEqualTo(beanDescriptor.idName());
       if (id != null) {
         whereExpressions = null;
       }
@@ -414,7 +414,7 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
     }
     if (orderBy != null) {
       for (Property orderProperty : orderBy.getProperties()) {
-        ElPropertyDeploy elProp = beanDescriptor.getElPropertyDeploy(orderProperty.getProperty());
+        ElPropertyDeploy elProp = beanDescriptor.elPropertyDeploy(orderProperty.getProperty());
         if (elProp != null && elProp.containsFormulaWithJoin()) {
           manyWhereJoins.addFormulaWithJoin(orderProperty.getProperty());
         }
@@ -588,7 +588,7 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
   public void setSelectId() {
     // clear select and fetch joins..
     detail.clear();
-    select(beanDescriptor.getIdBinder().getIdProperty());
+    select(beanDescriptor.idBinder().getIdProperty());
   }
 
   @Override
@@ -641,7 +641,7 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
     if (whereExpressions == null) {
       return null;
     }
-    BeanNaturalKey naturalKey = beanDescriptor.getNaturalKey();
+    BeanNaturalKey naturalKey = beanDescriptor.naturalKey();
     if (naturalKey == null) {
       return null;
     }
@@ -838,7 +838,7 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
   @Override
   public void setDefaultRawSqlIfRequired() {
     if (beanDescriptor.isRawSqlBased() && rawSql == null) {
-      rawSql = beanDescriptor.getNamedRawSql(DEFAULT_QUERY_NAME);
+      rawSql = beanDescriptor.namedRawSql(DEFAULT_QUERY_NAME);
     }
   }
 
@@ -1014,8 +1014,8 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
     if (useDocStore) {
       sb.append("/ds");
     }
-    if (beanDescriptor.getDiscValue() != null) {
-      sb.append("/dv").append(beanDescriptor.getDiscValue());
+    if (beanDescriptor.discValue() != null) {
+      sb.append("/dv").append(beanDescriptor.discValue());
     }
     if (temporalMode != SpiQuery.TemporalMode.CURRENT) {
       sb.append("/tm").append(temporalMode.ordinal());
@@ -1232,10 +1232,8 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
 
   @Override
   public void resetBeanCacheAutoMode(boolean findOne) {
-    if (useBeanCache == CacheMode.AUTO) {
-      if (!findOne || useQueryCache != CacheMode.OFF) {
-        useBeanCache = CacheMode.OFF;
-      }
+    if (useBeanCache == CacheMode.AUTO && useQueryCache != CacheMode.OFF) {
+      useBeanCache = CacheMode.OFF;
     }
   }
 
@@ -1339,6 +1337,7 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
     return fetchInternal(path, null, FETCH_QUERY);
   }
 
+  @Override
   public Query<T> fetchCache(String path) {
     return fetchInternal(path, null, FETCH_CACHE);
   }
@@ -1689,7 +1688,7 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
 
   @Override
   public Class<? extends T> getInheritType() {
-    return beanDescriptor.getBeanType();
+    return beanDescriptor.type();
   }
 
   @SuppressWarnings("unchecked")
@@ -1698,12 +1697,12 @@ public final class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<
     if (type == beanType) {
       return this;
     }
-    InheritInfo inheritInfo = rootBeanDescriptor.getInheritInfo();
+    InheritInfo inheritInfo = rootBeanDescriptor.inheritInfo();
     inheritInfo = inheritInfo == null ? null : inheritInfo.readType(type);
     if (inheritInfo == null) {
       throw new IllegalArgumentException("Given type " + type + " is not a subtype of " + beanType);
     }
-    beanDescriptor = (BeanDescriptor<T>) rootBeanDescriptor.getBeanDescriptor(type);
+    beanDescriptor = (BeanDescriptor<T>) rootBeanDescriptor.descriptor(type);
     return this;
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultUpdateQuery.java b/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultUpdateQuery.java
index c9ed9ca11..494f4227a 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultUpdateQuery.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultUpdateQuery.java
@@ -27,8 +27,8 @@ public final class DefaultUpdateQuery<T> implements UpdateQuery<T> {
     if (value == null) {
       values.setNull(property);
     } else {
-      final BeanProperty beanProperty = descriptor.getBeanProperty(property);
-      final ScalarType<Object> scalarType = (beanProperty == null) ? null: beanProperty.getScalarType();
+      final BeanProperty beanProperty = descriptor.beanProperty(property);
+      final ScalarType<Object> scalarType = (beanProperty == null) ? null: beanProperty.scalarType();
       values.set(property, value, scalarType);
     }
     return this;
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/OrmQueryDetail.java b/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/OrmQueryDetail.java
index 90f4cbac1..fab176ecb 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/OrmQueryDetail.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/OrmQueryDetail.java
@@ -307,14 +307,14 @@ public final class OrmQueryDetail implements Serializable {
       } else {
         OrmQueryProperties parentProp = fetchPaths.get(parentPath);
         if (parentProp == null) {
-          ElPropertyValue el = d.getElGetValue(parentPath);
+          ElPropertyValue el = d.elGetValue(parentPath);
           if (el == null) {
-            throw new PersistenceException("Path [" + parentPath + "] not valid from " + d.getFullName());
+            throw new PersistenceException("Path [" + parentPath + "] not valid from " + d.fullName());
           }
           // add a missing parent path just fetching the Id property
-          BeanPropertyAssoc<?> assocOne = (BeanPropertyAssoc<?>) el.getBeanProperty();
+          BeanPropertyAssoc<?> assocOne = (BeanPropertyAssoc<?>) el.beanProperty();
           if (addId) {
-            parentProp = new OrmQueryProperties(parentPath, assocOne.getTargetIdProperty());
+            parentProp = new OrmQueryProperties(parentPath, assocOne.targetIdProperty());
           } else {
             parentProp = new OrmQueryProperties(parentPath, Collections.emptySet());
           }
@@ -370,9 +370,9 @@ public final class OrmQueryDetail implements Serializable {
     int idx = 0;
     for (Map.Entry<String, OrmQueryProperties> entry : fetchPaths.entrySet()) {
       String fetchPath = entry.getKey();
-      ElPropertyDeploy elProp = desc.getElPropertyDeploy(fetchPath);
+      ElPropertyDeploy elProp = desc.elPropertyDeploy(fetchPath);
       if (elProp == null) {
-        throw new PersistenceException("Invalid fetch path " + fetchPath + " from " + desc.getFullName());
+        throw new PersistenceException("Invalid fetch path " + fetchPath + " from " + desc.fullName());
       }
       entries.add(new FetchEntry(idx++, fetchPath, elProp, entry.getValue()));
     }
@@ -430,13 +430,13 @@ public final class OrmQueryDetail implements Serializable {
    */
   public void setDefaultSelectClause(BeanDescriptor<?> desc) {
     if (desc.hasDefaultSelectClause() && !hasSelectClause()) {
-      baseProps = new OrmQueryProperties(null, desc.getDefaultSelectClause());
+      baseProps = new OrmQueryProperties(null, desc.defaultSelectClause());
     }
     for (OrmQueryProperties joinProps : fetchPaths.values()) {
       if (!joinProps.hasSelectClause()) {
-        BeanDescriptor<?> assocDesc = desc.getBeanDescriptor(joinProps.getPath());
+        BeanDescriptor<?> assocDesc = desc.descriptor(joinProps.getPath());
         if (assocDesc != null && assocDesc.hasDefaultSelectClause()) {
-          fetch(joinProps.getPath(), assocDesc.getDefaultSelectClause(), joinProps.getFetchConfig());
+          fetch(joinProps.getPath(), assocDesc.defaultSelectClause(), joinProps.getFetchConfig());
         }
       }
     }
@@ -549,8 +549,8 @@ public final class OrmQueryDetail implements Serializable {
      */
     @Override
     public int compareTo(FetchEntry other) {
-      int fp = elProp.getFetchPreference();
-      int op = other.elProp.getFetchPreference();
+      int fp = elProp.fetchPreference();
+      int op = other.elProp.fetchPreference();
       if (fp == op) {
         return Integer.compare(index, other.index);
       } else {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/text/csv/TCsvReader.java b/ebean-core/src/main/java/io/ebeaninternal/server/text/csv/TCsvReader.java
index 2f3c0716b..ddd309760 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/text/csv/TCsvReader.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/text/csv/TCsvReader.java
@@ -124,12 +124,12 @@ public class TCsvReader<T> implements CsvReader<T> {
   @Override
   public void addDateTime(String propertyName, String dateTimeFormat, Locale locale) {
 
-    ExpressionPath elProp = descriptor.getExpressionPath(propertyName);
+    ExpressionPath elProp = descriptor.expressionPath(propertyName);
     if (!elProp.isDateTimeCapable()) {
       throw new TextException("Property " + propertyName + " is not DateTime capable");
     }
     if (dateTimeFormat == null) {
-      dateTimeFormat = getDefaultDateTimeFormat(elProp.getJdbcType());
+      dateTimeFormat = getDefaultDateTimeFormat(elProp.jdbcType());
     }
 
     if (locale == null) {
@@ -160,9 +160,9 @@ public class TCsvReader<T> implements CsvReader<T> {
   @Override
   public void addProperty(String propertyName, StringParser parser) {
 
-    ExpressionPath elProp = descriptor.getExpressionPath(propertyName);
+    ExpressionPath elProp = descriptor.expressionPath(propertyName);
     if (parser == null) {
-      parser = elProp.getStringParser();
+      parser = elProp.stringParser();
     }
     CsvColumn column = new CsvColumn(elProp, parser);
     columnList.add(column);
@@ -235,20 +235,20 @@ public class TCsvReader<T> implements CsvReader<T> {
 
   private void addPropertiesFromHeader(String[] line) {
     for (String aLine : line) {
-      ElPropertyValue elProp = descriptor.getElGetValue(aLine);
+      ElPropertyValue elProp = descriptor.elGetValue(aLine);
       if (elProp == null) {
         throw new TextException("Property [" + aLine + "] not found");
       }
 
-      if (Types.TIME == elProp.getJdbcType()) {
+      if (Types.TIME == elProp.jdbcType()) {
         addProperty(aLine, TIME_PARSER);
 
-      } else if (isDateTimeType(elProp.getJdbcType())) {
+      } else if (isDateTimeType(elProp.jdbcType())) {
         addDateTime(aLine, null, null);
 
       } else if (elProp.isAssocProperty()) {
-        BeanPropertyAssocOne<?> assocOne = (BeanPropertyAssocOne<?>) elProp.getBeanProperty();
-        String idProp = assocOne.getBeanDescriptor().getIdBinder().getIdProperty();
+        BeanPropertyAssocOne<?> assocOne = (BeanPropertyAssocOne<?>) elProp.beanProperty();
+        String idProp = assocOne.descriptor().idBinder().getIdProperty();
         addProperty(aLine + "." + idProp);
       } else {
         addProperty(aLine);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/text/json/DJsonContext.java b/ebean-core/src/main/java/io/ebeaninternal/server/text/json/DJsonContext.java
index b0706173c..cbfb73559 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/text/json/DJsonContext.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/text/json/DJsonContext.java
@@ -62,8 +62,8 @@ public final class DJsonContext implements SpiJsonContext {
   public DJsonContext(SpiEbeanServer server, JsonFactory jsonFactory, TypeManager typeManager) {
     this.server = server;
     this.jsonFactory = (jsonFactory != null) ? jsonFactory : new JsonFactory();
-    this.defaultObjectMapper = this.server.getServerConfig().getObjectMapper();
-    this.defaultInclude = this.server.getServerConfig().getJsonInclude();
+    this.defaultObjectMapper = this.server.config().getObjectMapper();
+    this.defaultInclude = this.server.config().getJsonInclude();
     this.jsonScalar = new DJsonScalar(typeManager);
   }
 
@@ -425,7 +425,7 @@ public final class DJsonContext implements SpiJsonContext {
    * Return the BeanDescriptor for the given bean type.
    */
   private <T> BeanDescriptor<T> getDescriptor(Class<T> beanType) {
-    BeanDescriptor<T> d = server.getBeanDescriptor(beanType);
+    BeanDescriptor<T> d = server.descriptor(beanType);
     if (d == null) {
       throw new RuntimeException("No BeanDescriptor found for " + beanType);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/text/json/WriteJson.java b/ebean-core/src/main/java/io/ebeaninternal/server/text/json/WriteJson.java
index 4ae521e16..17c9e9372 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/text/json/WriteJson.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/text/json/WriteJson.java
@@ -506,10 +506,10 @@ public final class WriteJson implements SpiJsonWriter {
         return true;
       if (currentIncludeProps != null) {
         // explicitly controlled by pathProperties
-        return currentIncludeProps.contains(prop.getName());
+        return currentIncludeProps.contains(prop.name());
       } else {
         // include only loaded properties
-        return currentBean._ebean_getIntercept().isLoadedProperty(prop.getPropertyIndex());
+        return currentBean._ebean_getIntercept().isLoadedProperty(prop.propertyIndex());
       }
     }
 
@@ -518,7 +518,7 @@ public final class WriteJson implements SpiJsonWriter {
         return false;
       } else if (!explicitAllProps && currentIncludeProps != null) {
         // explicitly controlled by pathProperties
-        return currentIncludeProps.contains(prop.getName());
+        return currentIncludeProps.contains(prop.name());
       } else {
         // by default include transient properties
         return true;
@@ -529,7 +529,7 @@ public final class WriteJson implements SpiJsonWriter {
     public void write(WriteJson writeJson) {
 
       try {
-        BeanProperty beanProp = desc.getIdProperty();
+        BeanProperty beanProp = desc.idProperty();
         if (beanProp != null) {
           if (isIncludeProperty(beanProp)) {
             beanProp.jsonWrite(writeJson, currentBean);
@@ -600,7 +600,7 @@ public final class WriteJson implements SpiJsonWriter {
   }
 
   private <T> BeanDescriptor<T> getDescriptor(Class<T> cls) {
-    BeanDescriptor<T> d = server.getBeanDescriptor(cls);
+    BeanDescriptor<T> d = server.descriptor(cls);
     if (d == null) {
       throw new RuntimeException("No BeanDescriptor found for " + cls);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BeanPersistIdMap.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BeanPersistIdMap.java
index 8274af4bb..4eba89103 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BeanPersistIdMap.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BeanPersistIdMap.java
@@ -37,7 +37,7 @@ public final class BeanPersistIdMap {
   }
 
   private BeanPersistIds getPersistIds(BeanDescriptor<?> desc) {
-    String beanType = desc.getFullName();
+    String beanType = desc.fullName();
     return beanMap.computeIfAbsent(beanType, k -> new BeanPersistIds(desc));
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BeanPersistIds.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BeanPersistIds.java
index 280f3c28f..919f0838d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BeanPersistIds.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BeanPersistIds.java
@@ -42,12 +42,12 @@ public final class BeanPersistIds implements BinaryWritable {
    */
   public BeanPersistIds(BeanDescriptor<?> desc) {
     this.beanDescriptor = desc;
-    this.descriptorId = desc.getDescriptorId();
+    this.descriptorId = desc.descriptorId();
   }
 
   public static BeanPersistIds readBinaryMessage(SpiEbeanServer server, BinaryReadContext input) throws IOException {
 
-    BeanDescriptor<?> desc = server.getBeanDescriptorById(input.readUTF());
+    BeanDescriptor<?> desc = server.descriptorById(input.readUTF());
     BeanPersistIds bp = new BeanPersistIds(desc);
     bp.read(input);
     return bp;
@@ -56,7 +56,7 @@ public final class BeanPersistIds implements BinaryWritable {
   private void read(BinaryReadContext dataInput) throws IOException {
 
     dataInput.readInt(); // legacy read type
-    ids = readIdList(dataInput.in(), beanDescriptor.getIdBinder());
+    ids = readIdList(dataInput.in(), beanDescriptor.idBinder());
   }
 
   @Override
@@ -69,7 +69,7 @@ public final class BeanPersistIds implements BinaryWritable {
       os.writeInt(0);
     } else {
       os.writeInt(ids.size());
-      IdBinder idBinder = beanDescriptor.getIdBinder();
+      IdBinder idBinder = beanDescriptor.idBinder();
       for (Object idValue : ids) {
         idBinder.writeData(os, idValue);
       }
@@ -94,7 +94,7 @@ public final class BeanPersistIds implements BinaryWritable {
     StringBuilder sb = new StringBuilder();
     sb.append("BeanIds[");
     if (beanDescriptor != null) {
-      sb.append(beanDescriptor.getFullName());
+      sb.append(beanDescriptor.fullName());
     } else {
       sb.append("descId:").append(descriptorId);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BulkEventListenerMap.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BulkEventListenerMap.java
index bcc91909f..5f14a8e2c 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BulkEventListenerMap.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/BulkEventListenerMap.java
@@ -28,7 +28,7 @@ public final class BulkEventListenerMap {
   }
 
   public void process(BulkTableEvent event) {
-    Entry entry = map.get(event.getTableName());
+    Entry entry = map.get(event.tableName());
     if (entry != null) {
       entry.process(event);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DefaultPersistenceContext.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DefaultPersistenceContext.java
index 1064bf8bc..fb3e53b9b 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DefaultPersistenceContext.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DefaultPersistenceContext.java
@@ -65,6 +65,7 @@ public final class DefaultPersistenceContext implements SpiPersistenceContext {
     return new DefaultPersistenceContext(this, false);
   }
 
+  @Override
   public boolean resetLimit() {
     lock.lock();
     try {
@@ -335,7 +336,7 @@ public final class DefaultPersistenceContext implements SpiPersistenceContext {
      * Add the dirty beans to the list.
      */
     void dirtyBeans(SpiBeanTypeManager manager, List<Object> list) {
-      final SpiBeanType beanType = manager.getBeanType(rootType);
+      final SpiBeanType beanType = manager.beanType(rootType);
       for (Object value : map.values()) {
         EntityBean bean = (EntityBean) value;
         if (bean._ebean_getIntercept().isDirty() || beanType.isToManyDirty(bean)) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DeleteByIdMap.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DeleteByIdMap.java
index ca2cc1f27..675169318 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DeleteByIdMap.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DeleteByIdMap.java
@@ -63,7 +63,7 @@ public final class DeleteByIdMap {
   }
 
   private BeanPersistIds getPersistIds(BeanDescriptor<?> desc) {
-    String beanType = desc.getFullName();
+    String beanType = desc.fullName();
     return beanMap.computeIfAbsent(beanType, k -> new BeanPersistIds(desc));
   }
 
@@ -73,11 +73,11 @@ public final class DeleteByIdMap {
   void addDocStoreUpdates(DocStoreUpdates docStoreUpdates, DocStoreMode txnIndexMode) {
     for (BeanPersistIds deleteIds : beanMap.values()) {
       BeanDescriptor<?> desc = deleteIds.getBeanDescriptor();
-      DocStoreMode mode = desc.getDocStoreMode(PersistRequest.Type.DELETE, txnIndexMode);
+      DocStoreMode mode = desc.docStoreMode(PersistRequest.Type.DELETE, txnIndexMode);
       if (DocStoreMode.IGNORE != mode) {
         // Add to queue or bulk update entries
         boolean queue = (DocStoreMode.QUEUE == mode);
-        String queueId = desc.getDocStoreQueueId();
+        String queueId = desc.docStoreQueueId();
         List<Object> idValues = deleteIds.getIds();
         if (idValues != null) {
           for (Object idValue : idValues) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DocStoreOnlyTransaction.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DocStoreOnlyTransaction.java
index 0165fb1e8..9ff36d545 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DocStoreOnlyTransaction.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/DocStoreOnlyTransaction.java
@@ -35,7 +35,7 @@ public final class DocStoreOnlyTransaction extends JdbcTransaction {
   }
 
   @Override
-  public Connection getConnection() {
+  public Connection connection() {
     throw new RuntimeException("not supported on DocStoreTransaction");
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/ImplicitReadOnlyTransaction.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/ImplicitReadOnlyTransaction.java
index cbb4f7618..4948eb9ef 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/ImplicitReadOnlyTransaction.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/ImplicitReadOnlyTransaction.java
@@ -503,7 +503,7 @@ final class ImplicitReadOnlyTransaction implements SpiTransaction, TxnProfileEve
    * Return the underlying connection for public use.
    */
   @Override
-  public Connection getConnection() {
+  public Connection connection() {
     return getInternalConnection();
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/JdbcTransaction.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/JdbcTransaction.java
index d271d1c04..b1909b1f8 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/JdbcTransaction.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/JdbcTransaction.java
@@ -886,7 +886,7 @@ class JdbcTransaction implements SpiTransaction, TxnProfileEventCodes {
    * Return the underlying connection for public use.
    */
   @Override
-  public Connection getConnection() {
+  public Connection connection() {
     queryOnly = false;
     return getInternalConnection();
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/NoTransaction.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/NoTransaction.java
index 0ed17e94f..8bccacfc6 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/NoTransaction.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/NoTransaction.java
@@ -288,7 +288,7 @@ final class NoTransaction implements SpiTransaction {
   }
 
   @Override
-  public Connection getConnection() {
+  public Connection connection() {
     return null;
   }
 
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/TransactionFactory.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/TransactionFactory.java
index 687741654..ea2bc8aa0 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/TransactionFactory.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/TransactionFactory.java
@@ -35,7 +35,7 @@ abstract class TransactionFactory {
    */
   final SpiTransaction setIsolationLevel(SpiTransaction t, boolean explicit, int isolationLevel) {
     if (isolationLevel > -1) {
-      Connection connection = t.getConnection();
+      Connection connection = t.connection();
       try {
         connection.setTransactionIsolation(isolationLevel);
       } catch (SQLException e) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/TransactionManager.java b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/TransactionManager.java
index 37a53f680..aa2af72b0 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/transaction/TransactionManager.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/transaction/TransactionManager.java
@@ -48,16 +48,13 @@ import java.util.concurrent.atomic.AtomicLong;
 public class TransactionManager implements SpiTransactionManager {
 
   private static final Logger logger = LoggerFactory.getLogger(TransactionManager.class);
-
   private static final Logger clusterLogger = LoggerFactory.getLogger("io.ebean.Cluster");
 
   private final SpiServer server;
-
   private final BeanDescriptorManager beanDescriptorManager;
 
   /**
-   * Ebean defaults this to true but for EJB compatible behaviour set this to
-   * false;
+   * Ebean defaults this to true but for EJB compatible behaviour set this to false;
    */
   private final boolean rollbackOnChecked;
 
@@ -65,9 +62,7 @@ public class TransactionManager implements SpiTransactionManager {
    * Prefix for transaction id's (logging).
    */
   final String prefix;
-
   private final String externalTransPrefix;
-
   private final AtomicLong counter = new AtomicLong(1000L);
 
   /**
@@ -80,69 +75,38 @@ public class TransactionManager implements SpiTransactionManager {
    * to close queryOnly transactions rather than commit or rollback them.
    */
   private final OnQueryOnly onQueryOnly;
-
   private final BackgroundExecutor backgroundExecutor;
-
   private final ClusterManager clusterManager;
-
   private final String serverName;
-
   private final boolean docStoreActive;
 
   /**
    * The elastic search index update processor.
    */
   final DocStoreUpdateProcessor docStoreUpdateProcessor;
-
   private final boolean autoPersistUpdates;
-
   private final boolean persistBatch;
-
   private final boolean persistBatchOnCascade;
-
   private final BulkEventListenerMap bulkEventListenerMap;
-
-  /**
-   * Used to prepare the change set setting user context information in the
-   * foreground thread before logging.
-   */
   private final ChangeLogPrepare changeLogPrepare;
-
-  /**
-   * Performs the actual logging of the change set in background.
-   */
   private final ChangeLogListener changeLogListener;
-
-  /**
-   * Use Background executor to perform change-logging
-   */
   private final boolean changeLogAsync;
-
   final boolean notifyL2CacheInForeground;
-
   private final boolean viewInvalidation;
-
   private final boolean skipCacheAfterWrite;
-
   private final TransactionFactory transactionFactory;
-
   private final SpiLogManager logManager;
   private final SpiLogger txnLogger;
   private final boolean txnDebug;
-
   private final DatabasePlatform databasePlatform;
-
   private final SpiProfileHandler profileHandler;
-
   private final TimedMetric txnMain;
   private final TimedMetric txnReadOnly;
   private final TimedMetricMap txnNamed;
   private final TransactionScopeManager scopeManager;
-
   private final TableModState tableModState;
   private final ServerCacheNotify cacheNotify;
   private final boolean supportsSavepointId;
-
   private final ConcurrentHashMap<String, ProfileLocation> profileLocations = new ConcurrentHashMap<>();
 
   /**
@@ -163,8 +127,8 @@ public class TransactionManager implements SpiTransactionManager {
     this.rollbackOnChecked = options.config.isTransactionRollbackOnChecked();
     this.beanDescriptorManager = options.descMgr;
     this.viewInvalidation = options.descMgr.requiresViewEntityCacheInvalidation();
-    this.changeLogPrepare = options.descMgr.getChangeLogPrepare();
-    this.changeLogListener = options.descMgr.getChangeLogListener();
+    this.changeLogPrepare = options.descMgr.changeLogPrepare();
+    this.changeLogListener = options.descMgr.changeLogListener();
     this.changeLogAsync = options.config.isChangeLogAsync();
     this.clusterManager = options.clusterManager;
     this.serverName = options.config.getName();
@@ -201,6 +165,7 @@ public class TransactionManager implements SpiTransactionManager {
   /**
    * Return the scope manager.
    */
+  @Override
   public final TransactionScopeManager scope() {
     return scopeManager;
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/ArrayElementConverter.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/ArrayElementConverter.java
index f2c2c1ee7..372de8c86 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/type/ArrayElementConverter.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/ArrayElementConverter.java
@@ -104,6 +104,7 @@ interface ArrayElementConverter<T> {
    */
   class StringConverter implements ArrayElementConverter<String> {
 
+    @Override
     public String fromDbArray(Object rawValue) {
       return (String) rawValue;
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/DefaultTypeManager.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/DefaultTypeManager.java
index d58c284f3..5d95efd6e 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/type/DefaultTypeManager.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/DefaultTypeManager.java
@@ -162,30 +162,22 @@ public final class DefaultTypeManager implements TypeManager {
     }
   }
 
-  /**
-   * Return the factory to use to support DB ARRAY types.
-   */
   private PlatformArrayTypeFactory arrayTypeListFactory(DatabasePlatform databasePlatform) {
     if (databasePlatform.isNativeArrayType()) {
       return ScalarTypeArrayList.factory();
     } else if (databasePlatform.isPlatform(Platform.H2)) {
       return ScalarTypeArrayListH2.factory();
     }
-    // not supported for this DB platform
-    return null;
+    return new PlatformArrayTypeJsonList();
   }
 
-  /**
-   * Return the factory to use to support DB ARRAY types.
-   */
   private PlatformArrayTypeFactory arrayTypeSetFactory(DatabasePlatform databasePlatform) {
     if (databasePlatform.isNativeArrayType()) {
       return ScalarTypeArraySet.factory();
     } else if (databasePlatform.isPlatform(Platform.H2)) {
       return ScalarTypeArraySetH2.factory();
     }
-    // not supported for this DB platform
-    return null;
+    return new PlatformArrayTypeJsonSet();
   }
 
   /**
@@ -305,25 +297,17 @@ public final class DefaultTypeManager implements TypeManager {
   }
 
   private ScalarType<?> getArrayScalarTypeSet(Type valueType, boolean nullable) {
-    if (arrayTypeSetFactory != null) {
-      if (isEnumType(valueType)) {
-        return arrayTypeSetFactory.typeForEnum(createEnumScalarType(asEnumClass(valueType), null), nullable);
-      }
-      return arrayTypeSetFactory.typeFor(valueType, nullable);
+    if (isEnumType(valueType)) {
+      return arrayTypeSetFactory.typeForEnum(createEnumScalarType(asEnumClass(valueType), null), nullable);
     }
-    // fallback to JSON storage in VARCHAR column
-    return new ScalarTypeJsonSet.Varchar(getDocType(valueType), nullable, false); // TODO: keepSource for @DbArray?
+    return arrayTypeSetFactory.typeFor(valueType, nullable);
   }
 
   private ScalarType<?> getArrayScalarTypeList(Type valueType, boolean nullable) {
-    if (arrayTypeListFactory != null) {
-      if (isEnumType(valueType)) {
-        return arrayTypeListFactory.typeForEnum(createEnumScalarType(asEnumClass(valueType), null), nullable);
-      }
-      return arrayTypeListFactory.typeFor(valueType, nullable);
+    if (isEnumType(valueType)) {
+      return arrayTypeListFactory.typeForEnum(createEnumScalarType(asEnumClass(valueType), null), nullable);
     }
-    // fallback to JSON storage in VARCHAR column
-    return new ScalarTypeJsonList.Varchar(getDocType(valueType), nullable, false); // TODO: keepSource for @DbArray?
+    return arrayTypeListFactory.typeFor(valueType, nullable);
   }
 
   private Class<? extends Enum<?>> asEnumClass(Type valueType) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/PlatformArrayTypeJsonList.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/PlatformArrayTypeJsonList.java
new file mode 100644
index 000000000..8b3232b28
--- /dev/null
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/PlatformArrayTypeJsonList.java
@@ -0,0 +1,41 @@
+package io.ebeaninternal.server.type;
+
+import io.ebean.core.type.DocPropertyType;
+import io.ebean.core.type.ScalarType;
+
+import java.lang.reflect.Type;
+import java.util.UUID;
+
+/**
+ * Fallback for DbArray as Json List.
+ */
+class PlatformArrayTypeJsonList implements PlatformArrayTypeFactory {
+
+  private DocPropertyType docType(Type valueType) {
+    if (valueType.equals(Long.class)) {
+      return DocPropertyType.LONG;
+    }
+    if (valueType.equals(Integer.class)) {
+      return DocPropertyType.INTEGER;
+    }
+    if (valueType.equals(Double.class)) {
+      return DocPropertyType.DOUBLE;
+    }
+    return DocPropertyType.TEXT;
+  }
+
+  @Override
+  public ScalarType<?> typeFor(Type valueType, boolean nullable) {
+    if (valueType.equals(UUID.class)) {
+      // TODO: keepSource for @DbArray?
+      return new ScalarTypeJsonList.VarcharWithConverter(DocPropertyType.UUID, nullable, false, ArrayElementConverter.UUID);
+    }
+    return new ScalarTypeJsonList.Varchar(docType(valueType), nullable, false);
+  }
+
+  @Override
+  public ScalarType<?> typeForEnum(ScalarType<?> scalarType, boolean nullable) {
+    final ArrayElementConverter.EnumConverter converter = new ArrayElementConverter.EnumConverter(scalarType);
+    return new ScalarTypeJsonList.VarcharWithConverter(scalarType.getDocType(), nullable, false, converter);
+  }
+}
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/PlatformArrayTypeJsonSet.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/PlatformArrayTypeJsonSet.java
new file mode 100644
index 000000000..a5c7595f7
--- /dev/null
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/PlatformArrayTypeJsonSet.java
@@ -0,0 +1,41 @@
+package io.ebeaninternal.server.type;
+
+import io.ebean.core.type.DocPropertyType;
+import io.ebean.core.type.ScalarType;
+
+import java.lang.reflect.Type;
+import java.util.UUID;
+
+/**
+ * Fallback for DbArray as Json Set.
+ */
+class PlatformArrayTypeJsonSet implements PlatformArrayTypeFactory {
+
+  private DocPropertyType docType(Type valueType) {
+    if (valueType.equals(Long.class)) {
+      return DocPropertyType.LONG;
+    }
+    if (valueType.equals(Integer.class)) {
+      return DocPropertyType.INTEGER;
+    }
+    if (valueType.equals(Double.class)) {
+      return DocPropertyType.DOUBLE;
+    }
+    return DocPropertyType.TEXT;
+  }
+
+  @Override
+  public ScalarType<?> typeFor(Type valueType, boolean nullable) {
+    if (valueType.equals(UUID.class)) {
+      // TODO: keepSource for @DbArray?
+      return new ScalarTypeJsonSet.VarcharWithConverter(DocPropertyType.UUID, nullable, false, ArrayElementConverter.UUID);
+    }
+    return new ScalarTypeJsonSet.Varchar(docType(valueType), nullable, false);
+  }
+
+  @Override
+  public ScalarType<?> typeForEnum(ScalarType<?> scalarType, boolean nullable) {
+    final ArrayElementConverter.EnumConverter converter = new ArrayElementConverter.EnumConverter(scalarType);
+    return new ScalarTypeJsonSet.VarcharWithConverter(scalarType.getDocType(), nullable, false, converter);
+  }
+}
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeInteger.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeInteger.java
index 172522224..0e1ef6075 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeInteger.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeInteger.java
@@ -71,6 +71,11 @@ final class ScalarTypeInteger extends ScalarTypeBase<Integer> {
     return BasicTypeConverter.toInteger(value);
   }
 
+  @Override
+  public String format(Object value) {
+    return String.valueOf(value);
+  }
+
   @Override
   public String formatValue(Integer v) {
     return v.toString();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeJsonList.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeJsonList.java
index 71179dba7..4abd85931 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeJsonList.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeJsonList.java
@@ -9,11 +9,13 @@ import io.ebean.core.type.DocPropertyType;
 import io.ebean.core.type.ScalarType;
 import io.ebean.text.TextException;
 import io.ebean.text.json.EJson;
+import io.ebeaninternal.json.ModifyAwareList;
 
 import javax.persistence.PersistenceException;
 import java.io.IOException;
 import java.sql.SQLException;
 import java.sql.Types;
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -36,6 +38,46 @@ final class ScalarTypeJsonList {
     return new ScalarTypeJsonList.Varchar(docType, nullable, keepSource);
   }
 
+  @SuppressWarnings("rawtypes")
+  static final class VarcharWithConverter extends ScalarTypeJsonList.Base {
+    private final ArrayElementConverter converter;
+
+    VarcharWithConverter(DocPropertyType docType, boolean nullable, boolean keepSource, ArrayElementConverter converter) {
+      super(Types.VARCHAR, docType, nullable, keepSource);
+      this.converter = converter;
+    }
+
+    @Override
+    List readJsonConvert(String json) {
+      try {
+        return convertElements(EJson.parseList(json, false));
+      } catch (IOException e) {
+        throw new TextException("Failed to parse JSON [{}] as List", json, e);
+      }
+    }
+
+    @SuppressWarnings("unchecked")
+    private List convertElements(List<Object> rawList) {
+      if (rawList == null) {
+        return null;
+      }
+      final List result = new ArrayList<>(rawList.size());
+      for (Object o : rawList) {
+        result.add(converter.fromSerialized(o));
+      }
+      return new ModifyAwareList(result);
+    }
+
+    @Override
+    public List parse(String value) {
+      try {
+        return convertElements(EJson.parseList(value, false));
+      } catch (IOException e) {
+        throw new TextException("Failed to parse JSON [{}] as List", value, e);
+      }
+    }
+  }
+
   /**
    * List mapped to DB VARCHAR.
    */
@@ -86,6 +128,10 @@ final class ScalarTypeJsonList {
       if (keepSource) {
         reader.pushJson(json);
       }
+      return readJsonConvert(json);
+    }
+
+    List readJsonConvert(String json) {
       try {
         // parse JSON into modifyAware list
         return EJson.parseList(json, true);
@@ -130,7 +176,7 @@ final class ScalarTypeJsonList {
     }
 
     @Override
-    public final List parse(String value) {
+    public List parse(String value) {
       try {
         return EJson.parseList(value, false);
       } catch (IOException e) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeJsonSet.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeJsonSet.java
index 50cc7f0b3..354d793d7 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeJsonSet.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeJsonSet.java
@@ -9,6 +9,7 @@ import io.ebean.core.type.DocPropertyType;
 import io.ebean.core.type.ScalarType;
 import io.ebean.text.TextException;
 import io.ebean.text.json.EJson;
+import io.ebeaninternal.json.ModifyAwareSet;
 
 import javax.persistence.PersistenceException;
 import java.io.IOException;
@@ -38,6 +39,45 @@ final class ScalarTypeJsonSet {
     return new ScalarTypeJsonSet.Varchar(docPropertyType, nullable, keepSource);
   }
 
+  @SuppressWarnings("rawtypes")
+  static final class VarcharWithConverter extends ScalarTypeJsonSet.Base {
+    private final ArrayElementConverter converter;
+
+    VarcharWithConverter(DocPropertyType docType, boolean nullable, boolean keepSource, ArrayElementConverter converter) {
+      super(Types.VARCHAR, docType, nullable, keepSource);
+      this.converter = converter;
+    }
+
+    @Override
+    Set readJsonConvert(String json) {
+      try {
+        return convertElements(EJson.parseSet(json, false));
+      } catch (IOException e) {
+        throw new TextException("Failed to parse JSON [{}] as List", json, e);
+      }
+    }
+
+    @SuppressWarnings("unchecked")
+    private Set convertElements(Set<Object> rawSet) {
+      if (rawSet == null) {
+        return null;
+      }
+      final Set result = new LinkedHashSet(rawSet.size());
+      for (Object o : rawSet) {
+        result.add(converter.fromSerialized(o));
+      }
+      return new ModifyAwareSet(result);
+    }
+
+    @Override
+    public Set parse(String value) {
+      try {
+        return convertElements(EJson.parseSet(value, false));
+      } catch (IOException e) {
+        throw new PersistenceException("Failed to parse JSON content as Set: [" + value + "]", e);
+      }
+    }
+  }
   /**
    * List mapped to DB VARCHAR.
    */
@@ -86,8 +126,11 @@ final class ScalarTypeJsonSet {
       if (keepSource) {
         reader.pushJson(json);
       }
+      return readJsonConvert(json);
+    }
+
+    Set readJsonConvert(String json) {
       try {
-        // parse JSON into modifyAware list
         return EJson.parseSet(json, true);
       } catch (IOException e) {
         throw new TextException("Failed to parse JSON [{}] as Set", json, e);
@@ -130,7 +173,7 @@ final class ScalarTypeJsonSet {
     }
 
     @Override
-    public final Set parse(String value) {
+    public Set parse(String value) {
       try {
         return convertList(EJson.parseList(value));
       } catch (IOException e) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeLocalDate.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeLocalDate.java
index 286818c37..630fe73a3 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeLocalDate.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeLocalDate.java
@@ -19,6 +19,7 @@ final class ScalarTypeLocalDate extends ScalarTypeBaseDate<LocalDate> {
     super(mode, LocalDate.class, false, Types.DATE);
   }
 
+  @Override
   protected String toIsoFormat(LocalDate value) {
     return value.toString();
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeLong.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeLong.java
index 5287c5fd5..3409cc9ed 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeLong.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeLong.java
@@ -46,6 +46,11 @@ final class ScalarTypeLong extends ScalarTypeBase<Long> {
     return BasicTypeConverter.toLong(value);
   }
 
+  @Override
+  public String format(Object value) {
+    return String.valueOf(value);
+  }
+
   @Override
   public String formatValue(Long t) {
     return t.toString();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeUUIDBase.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeUUIDBase.java
index abf91811b..7da989b82 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeUUIDBase.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeUUIDBase.java
@@ -35,6 +35,11 @@ abstract class ScalarTypeUUIDBase extends ScalarTypeBase<UUID> implements Scalar
     return true;
   }
 
+  @Override
+  public String format(Object value) {
+    return String.valueOf(value);
+  }
+
   @Override
   public String formatValue(UUID value) {
     return value.toString();
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeUtilDate.java b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeUtilDate.java
index 3a816d498..725d76055 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeUtilDate.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/type/ScalarTypeUtilDate.java
@@ -95,6 +95,7 @@ final class ScalarTypeUtilDate {
       super(mode, Date.class, false, Types.DATE);
     }
 
+    @Override
     protected String toIsoFormat(java.util.Date value) {
       return UtilDateParser.format(value);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/util/BindParamsParser.java b/ebean-core/src/main/java/io/ebeaninternal/server/util/BindParamsParser.java
index b28f6b80f..cd14831e5 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/util/BindParamsParser.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/util/BindParamsParser.java
@@ -206,7 +206,7 @@ public final class BindParamsParser {
     String tableName = keyNamedParam.substring(ENCRYPTKEY_PREFIX_LEN, pos);
     String columnName = keyNamedParam.substring(pos + ENCRYPTKEY_GAP_LEN);
 
-    EncryptKey key = beanDescriptor.getEncryptKey(tableName, columnName);
+    EncryptKey key = beanDescriptor.encryptKey(tableName, columnName);
     String strKey = key.getStringValue();
 
     return params.setEncryptionKey(keyNamedParam, strKey);
diff --git a/ebean-core/src/main/java/io/ebeanservice/docstore/api/DocQueryRequest.java b/ebean-core/src/main/java/io/ebeanservice/docstore/api/DocQueryRequest.java
index 004047976..d8548d1b2 100644
--- a/ebean-core/src/main/java/io/ebeanservice/docstore/api/DocQueryRequest.java
+++ b/ebean-core/src/main/java/io/ebeanservice/docstore/api/DocQueryRequest.java
@@ -13,17 +13,17 @@ public interface DocQueryRequest<T> extends DocQueryContext<T> {
   /**
    * Return the transaction for this request (can be null for document store only queries).
    */
-  SpiTransaction getTransaction();
+  SpiTransaction transaction();
 
   /**
    * Set the (document store) transaction to use for this query.
    */
-  void setTransaction(SpiTransaction transaction);
+  void transaction(SpiTransaction transaction);
 
   /**
    * Return the query for this request.
    */
-  SpiQuery<T> getQuery();
+  SpiQuery<T> query();
 
   /**
    * Create JsonReadOptions taking into account persistence context and lazy loading support.
diff --git a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreBeanBaseAdapter.java b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreBeanBaseAdapter.java
index 7212f74ee..4cd2b692f 100644
--- a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreBeanBaseAdapter.java
+++ b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreBeanBaseAdapter.java
@@ -104,7 +104,7 @@ public abstract class DocStoreBeanBaseAdapter<T> implements DocStoreBeanAdapter<
   public DocStoreBeanBaseAdapter(BeanDescriptor<T> desc, DeployBeanDescriptor<T> deploy) {
 
     this.desc = desc;
-    this.server = desc.getEbeanServer();
+    this.server = desc.ebeanServer();
     this.mapped = deploy.isDocStoreMapped();
     this.pathProps = deploy.getDocStorePathProperties();
     this.docStore = deploy.getDocStore();
@@ -174,12 +174,12 @@ public abstract class DocStoreBeanBaseAdapter<T> implements DocStoreBeanAdapter<
       for (PathProperties.Props pathProp : pathProps) {
         String path = pathProp.getPath();
         if (path != null) {
-          BeanDescriptor<?> targetDesc = desc.getBeanDescriptor(path);
-          BeanProperty idProperty = targetDesc.getIdProperty();
+          BeanDescriptor<?> targetDesc = desc.descriptor(path);
+          BeanProperty idProperty = targetDesc.idProperty();
           if (idProperty != null) {
             // embedded beans don't have id property
-            String fullPath = path + "." + idProperty.getName();
-            targetDesc.docStoreAdapter().registerInvalidationPath(desc.getDocStoreQueueId(), fullPath, pathProp.getProperties());
+            String fullPath = path + "." + idProperty.name();
+            targetDesc.docStoreAdapter().registerInvalidationPath(desc.docStoreQueueId(), fullPath, pathProp.getProperties());
           }
         }
       }
@@ -221,9 +221,9 @@ public abstract class DocStoreBeanBaseAdapter<T> implements DocStoreBeanAdapter<
   protected int[] getPropertyPositions(Set<String> properties) {
     List<Integer> posList = new ArrayList<>();
     for (String property : properties) {
-      BeanProperty prop = desc.getBeanProperty(property);
+      BeanProperty prop = desc.beanProperty(property);
       if (prop != null) {
-        posList.add(prop.getPropertyIndex());
+        posList.add(prop.propertyIndex());
       }
     }
     int[] pos = new int[posList.size()];
@@ -263,7 +263,7 @@ public abstract class DocStoreBeanBaseAdapter<T> implements DocStoreBeanAdapter<
       property.docStoreInclude(includeByDefault, docStructure);
     }
 
-    InheritInfo inheritInfo = desc.getInheritInfo();
+    InheritInfo inheritInfo = desc.inheritInfo();
     if (inheritInfo != null) {
       inheritInfo.visitChildren(inheritInfo1 -> {
         for (BeanProperty localProperty : inheritInfo1.localProperties()) {
@@ -323,7 +323,7 @@ public abstract class DocStoreBeanBaseAdapter<T> implements DocStoreBeanAdapter<
    * Return the supplied value or default to the bean name lower case.
    */
   protected String derive(BeanType<?> desc, String suppliedValue) {
-    return (suppliedValue != null && !suppliedValue.isEmpty()) ? suppliedValue : desc.getName().toLowerCase();
+    return (suppliedValue != null && !suppliedValue.isEmpty()) ? suppliedValue : desc.name().toLowerCase();
   }
 
   @Override
diff --git a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreDeleteEvent.java b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreDeleteEvent.java
index 9c758b426..35c120bd4 100644
--- a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreDeleteEvent.java
+++ b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreDeleteEvent.java
@@ -34,6 +34,6 @@ public class DocStoreDeleteEvent implements DocStoreUpdate {
    */
   @Override
   public void addToQueue(DocStoreUpdates docStoreUpdates) {
-    docStoreUpdates.queueDelete(beanType.getDocStoreQueueId(), idValue);
+    docStoreUpdates.queueDelete(beanType.docStoreQueueId(), idValue);
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreEmbeddedInvalidation.java b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreEmbeddedInvalidation.java
index 3a8e22403..bbf5ca009 100644
--- a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreEmbeddedInvalidation.java
+++ b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreEmbeddedInvalidation.java
@@ -18,6 +18,6 @@ public class DocStoreEmbeddedInvalidation {
   }
 
   public void embeddedInvalidate(PersistRequestBean<?> request, DocStoreUpdates docStoreUpdates) {
-    docStoreUpdates.addNested(queueId, path, request.getBeanId());
+    docStoreUpdates.addNested(queueId, path, request.beanId());
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreEmbeddedInvalidationProperties.java b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreEmbeddedInvalidationProperties.java
index 56b8cf39d..38f93a8a8 100644
--- a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreEmbeddedInvalidationProperties.java
+++ b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreEmbeddedInvalidationProperties.java
@@ -23,7 +23,7 @@ public final class DocStoreEmbeddedInvalidationProperties extends DocStoreEmbedd
   @Override
   public void embeddedInvalidate(PersistRequestBean<?> request, DocStoreUpdates docStoreUpdates) {
     if (request.hasDirtyProperty(properties)) {
-      docStoreUpdates.addNested(queueId, path, request.getBeanId());
+      docStoreUpdates.addNested(queueId, path, request.beanId());
     }
   }
 
diff --git a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreIndexEvent.java b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreIndexEvent.java
index 20354a94c..ad1e5a706 100644
--- a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreIndexEvent.java
+++ b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStoreIndexEvent.java
@@ -37,6 +37,6 @@ public class DocStoreIndexEvent<T> implements DocStoreUpdate {
    */
   @Override
   public void addToQueue(DocStoreUpdates docStoreUpdates) {
-    docStoreUpdates.queueIndex(beanType.getDocStoreQueueId(), idValue);
+    docStoreUpdates.queueIndex(beanType.docStoreQueueId(), idValue);
   }
 }
diff --git a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStructure.java b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStructure.java
index e67e473f3..d2d3a3ac4 100644
--- a/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStructure.java
+++ b/ebean-core/src/main/java/io/ebeanservice/docstore/api/support/DocStructure.java
@@ -84,10 +84,10 @@ public class DocStructure {
    */
   private void prepare(String prop, BeanPropertyAssoc<?> embProp) {
 
-    BeanDescriptor<?> targetDesc = embProp.getTargetDescriptor();
+    BeanDescriptor<?> targetDesc = embProp.targetDescriptor();
 
     PathProperties manyRootPath = new PathProperties();
-    manyRootPath.addToPath(null, targetDesc.getIdProperty().getName());
+    manyRootPath.addToPath(null, targetDesc.idProperty().name());
     manyRootPath.addNested(prop, embedded.get(prop));
 
     manyRoot.put(prop, manyRootPath);
diff --git a/ebean-core/src/test/java/io/ebean/ConditionalTestRunner.java b/ebean-core/src/test/java/io/ebean/ConditionalTestRunner.java
deleted file mode 100644
index 4adf007d8..000000000
--- a/ebean-core/src/test/java/io/ebean/ConditionalTestRunner.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package io.ebean;
-
-import io.ebean.annotation.ForPlatform;
-import io.ebean.annotation.IgnorePlatform;
-import io.ebean.annotation.Platform;
-import org.junit.runner.notification.RunNotifier;
-import org.junit.runners.BlockJUnit4ClassRunner;
-import org.junit.runners.model.FrameworkMethod;
-import org.junit.runners.model.InitializationError;
-
-/**
- * This testrunner checks for an {@link IgnorePlatform} annotation and ignores the test.
- *
- * @author Roland Praml, FOCONIS AG
- */
-public class ConditionalTestRunner extends BlockJUnit4ClassRunner {
-  public ConditionalTestRunner(Class<?> klass) throws InitializationError {
-    super(klass);
-  }
-  @Override
-  public void runChild(FrameworkMethod method, RunNotifier notifier) {
-    ForPlatform forPlatform = method.getAnnotation(ForPlatform.class);
-    if (forPlatform != null) {
-      if (!platformMath(forPlatform.value())) {
-        notifier.fireTestIgnored(describeChild(method));
-        return;
-      }
-    }
-
-    IgnorePlatform ignore = method.getAnnotation(IgnorePlatform.class);
-
-    if (ignore == null || !platformMath(ignore.value())) {
-      super.runChild(method, notifier);
-    } else {
-      notifier.fireTestIgnored(describeChild(method));
-    }
-
-  }
-  private boolean platformMath(Platform[] platforms) {
-    Platform basePlatform = DB.getDefault().getPlatform().base();
-    for (Platform platform : platforms) {
-      if (platform.equals(basePlatform)) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
diff --git a/ebean-core/src/test/java/io/ebean/cache/ServerCacheManagerTest.java b/ebean-core/src/test/java/io/ebean/cache/ServerCacheManagerTest.java
deleted file mode 100644
index 337a80116..000000000
--- a/ebean-core/src/test/java/io/ebean/cache/ServerCacheManagerTest.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package io.ebean.cache;
-
-import io.ebean.DB;
-import org.junit.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-public class ServerCacheManagerTest {
-
-  @Test
-  public void test() {
-
-    ServerCacheManager cacheManager = DB.getDefault().getServerCacheManager();
-
-    for (ServerCacheRegion region : cacheManager.allRegions()) {
-      assertTrue(region.isEnabled());
-    }
-
-    cacheManager.setEnabledRegions("r0,doesNotExist");
-    assertThat(cacheManager.getRegion("email").isEnabled()).isFalse();
-    assertThat(cacheManager.getRegion("r0").isEnabled()).isTrue();
-
-    cacheManager.setEnabledRegions("r0");
-    assertThat(cacheManager.getRegion("email").isEnabled()).isFalse();
-    assertThat(cacheManager.getRegion("r0").isEnabled()).isTrue();
-
-    cacheManager.setEnabledRegions(null);
-    assertThat(cacheManager.getRegion("email").isEnabled()).isFalse();
-    assertThat(cacheManager.getRegion("r0").isEnabled()).isTrue();
-
-    cacheManager.setEnabledRegions("email");
-    assertThat(cacheManager.getRegion("email").isEnabled()).isTrue();
-    assertThat(cacheManager.getRegion("r0").isEnabled()).isFalse();
-
-    cacheManager.setAllRegionsEnabled(false);
-    for (ServerCacheRegion region : cacheManager.allRegions()) {
-      assertFalse(region.isEnabled());
-    }
-
-    cacheManager.setAllRegionsEnabled(true);
-    for (ServerCacheRegion region : cacheManager.allRegions()) {
-      assertTrue(region.isEnabled());
-    }
-
-  }
-}
diff --git a/ebean-core/src/test/java/io/ebean/plugin/PropertyTest.java b/ebean-core/src/test/java/io/ebean/plugin/PropertyTest.java
deleted file mode 100644
index 581d5a647..000000000
--- a/ebean-core/src/test/java/io/ebean/plugin/PropertyTest.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package io.ebean.plugin;
-
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.junit.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- */
-public class PropertyTest {
-
-  static EbeanServer server = Ebean.getDefaultServer();
-
-  <T> BeanType<T> beanType(Class<T> cls) {
-    return server.getPluginApi().getBeanType(cls);
-  }
-
-  @Test
-  public void getVal() throws Exception {
-
-    Customer customer = new Customer();
-
-    Order order = new Order();
-    order.setCustomer(customer);
-    order.setStatus(Order.Status.APPROVED);
-
-    Property statusProperty = beanType(Order.class).getProperty("status");
-    assertThat(statusProperty.getVal(order)).isEqualTo(order.getStatus());
-
-    Property customerProperty = beanType(Order.class).getProperty("customer");
-    assertThat(customerProperty.getVal(order)).isEqualTo(customer);
-  }
-
-  @Test
-  public void isMany_when_not() {
-
-    assertThat(beanType(Order.class).getProperty("status").isMany()).isFalse();
-    assertThat(beanType(Order.class).getProperty("customer").isMany()).isFalse();
-  }
-
-  @Test
-  public void isMany_when_true() {
-
-    assertThat(beanType(Order.class).getProperty("details").isMany()).isTrue();
-  }
-
-  @Test
-  public void name() {
-    assertThat(beanType(Order.class).getProperty("status").getName()).isEqualTo("status");
-    assertThat(beanType(Order.class).getProperty("customer").getName()).isEqualTo("customer");
-    assertThat(beanType(Order.class).getProperty("details").getName()).isEqualTo("details");
-  }
-}
diff --git a/ebean-core/src/test/java/io/ebean/plugin/SpiServerTest.java b/ebean-core/src/test/java/io/ebean/plugin/SpiServerTest.java
deleted file mode 100644
index 4ea9727de..000000000
--- a/ebean-core/src/test/java/io/ebean/plugin/SpiServerTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package io.ebean.plugin;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import org.tests.model.basic.Customer;
-import org.junit.Test;
-import org.tests.model.basic.VwCustomer;
-
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-
-public class SpiServerTest extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    EbeanServer defaultServer = Ebean.getDefaultServer();
-    SpiServer pluginApi = defaultServer.getPluginApi();
-
-    BeanType<Customer> beanType = pluginApi.getBeanType(Customer.class);
-    assertEquals("o_customer", beanType.getBaseTable());
-    assertNotNull(pluginApi.getDatabasePlatform());
-    assertNull(beanType.getFindController());
-    assertNotNull(beanType.getPersistController());
-    assertNull(beanType.getPersistListener());
-    assertNull(beanType.getQueryAdapter());
-
-    assertTrue(beanType.isValidExpression("name"));
-    assertTrue(beanType.isValidExpression("contacts.firstName"));
-    assertTrue(beanType.isValidExpression("contacts.group.name"));
-    assertFalse(beanType.isValidExpression("junk"));
-    assertFalse(beanType.isValidExpression("Name"));
-    assertFalse(beanType.isValidExpression("contacts.name"));
-
-    Customer customer = new Customer();
-    customer.setId(42);
-
-    assertEquals(42, beanType.getBeanId(customer));
-
-    List<? extends BeanType<?>> beanTypes = pluginApi.getBeanTypes("o_customer");
-    assertEquals(2, beanTypes.size());
-
-    BeanType<VwCustomer> vwBeanType = pluginApi.getBeanType(VwCustomer.class);
-
-    assertThat(beanTypes.contains(beanType)).isTrue();
-    assertThat(beanTypes.contains(vwBeanType)).isTrue();
-
-    List<? extends BeanType<?>> allTypes = pluginApi.getBeanTypes();
-    assertFalse(allTypes.isEmpty());
-  }
-
-}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_whenCreatedPropertyTest.java b/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_whenCreatedPropertyTest.java
deleted file mode 100644
index 4ea84d989..000000000
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_whenCreatedPropertyTest.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package io.ebeaninternal.server.deploy;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebeaninternal.api.SpiEbeanServer;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.EBasic;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-
-
-public class BeanDescriptor_whenCreatedPropertyTest extends BaseTestCase {
-
-
-  @Test
-  public void test() {
-
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getDefaultServer();
-
-    BeanDescriptor<Customer> desc = server.getBeanDescriptor(Customer.class);
-
-    BeanProperty whenCreatedProperty = desc.getWhenCreatedProperty();
-    assertEquals("cretime", whenCreatedProperty.getDbColumn());
-
-    BeanProperty whenModifiedProperty = desc.getWhenModifiedProperty();
-    assertEquals("updtime", whenModifiedProperty.getDbColumn());
-
-
-    BeanDescriptor<EBasic> eBasicDesc = server.getBeanDescriptor(EBasic.class);
-    assertNull(eBasicDesc.getWhenCreatedProperty());
-    assertNull(eBasicDesc.getWhenModifiedProperty());
-  }
-}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestNotEnhancedMappedSuper.java b/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestNotEnhancedMappedSuper.java
deleted file mode 100644
index 014ddb4b6..000000000
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestNotEnhancedMappedSuper.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package io.ebeaninternal.server.deploy;
-
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.bean.EntityBean;
-import org.tests.model.mappedsuper.ASimpleBean;
-import org.tests.model.mappedsuper.NotEnhancedMappedSuper;
-import org.junit.Assert;
-import org.junit.Test;
-
-public class TestNotEnhancedMappedSuper extends BaseTestCase {
-
-  @Test
-  public void simpleBean_mappedSuperNotEnhanced_ok() {
-
-    ASimpleBean bean = new ASimpleBean();
-    bean.setName("junk");
-
-    Ebean.save(bean);
-    Assert.assertNotNull(bean.getId());
-
-    bean.setName("junk mod");
-    Ebean.save(bean);
-
-    ASimpleBean fetched = Ebean.find(ASimpleBean.class, bean.getId());
-    Assert.assertEquals("junk mod", fetched.getName());
-    Assert.assertEquals(bean.getName(), fetched.getName());
-
-    Ebean.delete(bean);
-    ASimpleBean fetched2 = Ebean.find(ASimpleBean.class, bean.getId());
-    Assert.assertNull(fetched2);
-
-    NotEnhancedMappedSuper mappedSuper = new NotEnhancedMappedSuper();
-    boolean enhanced = (mappedSuper instanceof EntityBean);
-    Assert.assertTrue(enhanced);
-
-  }
-
-}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilderDistinct.java b/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilderDistinct.java
deleted file mode 100644
index 146b6d5e0..000000000
--- a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilderDistinct.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package io.ebeaninternal.server.rawsql;
-
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
-import io.ebeaninternal.server.rawsql.SpiRawSql.Sql;
-import junit.framework.TestCase;
-import org.junit.Assert;
-
-public class TestRawSqlBuilderDistinct extends TestCase {
-
-  public void testDistinct() {
-
-    RawSql r = RawSqlBuilder.parse("select distinct id, name from t_cust").create();
-    Sql sql = ((SpiRawSql)r).getSql();
-    Assert.assertEquals("id, name", sql.getPreFrom());
-    Assert.assertEquals("from t_cust", sql.getPreWhere());
-    Assert.assertEquals("", sql.getPreHaving());
-    Assert.assertNull(sql.getOrderBy());
-
-  }
-
-}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/TestLocaleParse.java b/ebean-core/src/test/java/io/ebeaninternal/server/type/TestLocaleParse.java
deleted file mode 100644
index 6e81002da..000000000
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/TestLocaleParse.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package io.ebeaninternal.server.type;
-
-import io.ebeaninternal.server.type.ScalarTypeLocale;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.Locale;
-
-public class TestLocaleParse {
-
-  @Test
-  public void test() {
-
-    // Examples: "en", "de_DE", "_GB", "en_US_WIN", "de__POSIX", "fr__MAC"
-
-    Locale l = parse("en");
-    Assert.assertEquals("en", l.getLanguage());
-
-    l = parse("de_DE");
-    Assert.assertEquals("de", l.getLanguage());
-    Assert.assertEquals("DE", l.getCountry());
-
-    l = parse("en_US_WIN");
-    Assert.assertEquals("en", l.getLanguage());
-    Assert.assertEquals("US", l.getCountry());
-    Assert.assertEquals("WIN", l.getVariant());
-
-    l = parse("_GB");
-    Assert.assertEquals("", l.getLanguage());
-    Assert.assertEquals("GB", l.getCountry());
-    Assert.assertEquals("", l.getVariant());
-
-    l = parse("fr__MAC");
-    Assert.assertEquals("fr", l.getLanguage());
-    Assert.assertEquals("", l.getCountry());
-    Assert.assertEquals("MAC", l.getVariant());
-
-    l = parse("de__POSIX");
-    Assert.assertEquals("de", l.getLanguage());
-    Assert.assertEquals("", l.getCountry());
-    Assert.assertEquals("POSIX", l.getVariant());
-  }
-
-  private Locale parse(String value) {
-
-    ScalarTypeLocale st = new ScalarTypeLocale();
-    return (Locale) st.parse(value);
-  }
-}
diff --git a/ebean-core/src/test/java/io/ebeantest/CaptureLogger.java b/ebean-core/src/test/java/io/ebeantest/CaptureLogger.java
deleted file mode 100644
index 4f0454ccd..000000000
--- a/ebean-core/src/test/java/io/ebeantest/CaptureLogger.java
+++ /dev/null
@@ -1,64 +0,0 @@
-package io.ebeantest;
-
-import io.ebeaninternal.api.SpiLogger;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Capture the log messages (executed SQL) for testing.
- */
-class CaptureLogger implements SpiLogger {
-
-  private final SpiLogger wrapped;
-
-  private List<String> messages = new ArrayList<>();
-
-  private boolean active;
-
-  CaptureLogger(SpiLogger wrapped) {
-    this.wrapped = wrapped;
-  }
-
-  @Override
-  public boolean isDebug() {
-    return true;
-  }
-
-  @Override
-  public boolean isTrace() {
-    return true;
-  }
-
-  @Override
-  public void debug(String msg) {
-    if (active) {
-      messages.add(msg);
-    }
-    wrapped.debug(msg);
-  }
-
-  @Override
-  public void trace(String msg) {
-    if (active) {
-      messages.add(msg);
-    }
-    wrapped.trace(msg);
-  }
-
-  List<String> start() {
-    this.active = true;
-    return collect();
-  }
-
-  List<String> stop() {
-    this.active = false;
-    return collect();
-  }
-
-  List<String> collect() {
-    List<String> response = messages;
-    messages = new ArrayList<>();
-    return response;
-  }
-}
diff --git a/ebean-core/src/test/java/io/ebeantest/CapturingLoggerFactory.java b/ebean-core/src/test/java/io/ebeantest/CapturingLoggerFactory.java
deleted file mode 100644
index ebbebd2fe..000000000
--- a/ebean-core/src/test/java/io/ebeantest/CapturingLoggerFactory.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package io.ebeantest;
-
-import io.ebeaninternal.api.SpiLogger;
-import io.ebeaninternal.api.SpiLoggerFactory;
-import io.ebeaninternal.server.logger.DSpiLogger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Create a logger that captures the SQL and register it for later access in tests.
- */
-public class CapturingLoggerFactory implements SpiLoggerFactory {
-
-  @Override
-  public SpiLogger create(String name) {
-
-    DSpiLogger logger = new DSpiLogger(LoggerFactory.getLogger(name));
-    if (name.equals("io.ebean.SQL")) {
-      return LoggedSql.register(logger);
-    }
-    return logger;
-  }
-}
diff --git a/ebean-core/src/test/java/io/ebeantest/LoggedSql.java b/ebean-core/src/test/java/io/ebeantest/LoggedSql.java
deleted file mode 100644
index db7cac92c..000000000
--- a/ebean-core/src/test/java/io/ebeantest/LoggedSql.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package io.ebeantest;
-
-import io.ebeaninternal.api.SpiLogger;
-import io.ebeaninternal.server.logger.DSpiLogger;
-
-import java.util.List;
-
-public class LoggedSql {
-
-  private static CaptureLogger sqlLogger;
-
-  static SpiLogger register(DSpiLogger logger) {
-    if (sqlLogger == null) {
-      sqlLogger = new CaptureLogger(logger);
-    }
-    return sqlLogger;
-  }
-
-  public static List<String> start() {
-    return sqlLogger.start();
-  }
-
-  public static List<String> stop() {
-    return sqlLogger.stop();
-  }
-
-  public static List<String> collect() {
-    return sqlLogger.collect();
-  }
-
-}
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/DfkNoneViaJoin.java b/ebean-core/src/test/java/misc/migration/v1_1/DfkNoneViaJoin.java
deleted file mode 100644
index dae77dd67..000000000
--- a/ebean-core/src/test/java/misc/migration/v1_1/DfkNoneViaJoin.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package misc.migration.v1_1;
-
-import javax.persistence.ConstraintMode;
-import javax.persistence.Entity;
-import javax.persistence.ForeignKey;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-
-@Entity
-@Table(name = "migtest_fk_none_via_join")
-public class DfkNoneViaJoin {
-
-  @Id
-  long id;
-
-  @ManyToOne
-  @JoinColumn(name = "one_id", foreignKey = @ForeignKey(ConstraintMode.CONSTRAINT))
-  DfkOne one;
-
-}
diff --git a/ebean-core/src/test/java/org/Main.java b/ebean-core/src/test/java/org/Main.java
deleted file mode 100644
index 9ce670947..000000000
--- a/ebean-core/src/test/java/org/Main.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package org;
-
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-
-import javax.sql.DataSource;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-
-public class Main {
-
-  public static void main(String[] args) throws SQLException {
-
-
-    EbeanServer ms = Ebean.getServer("ms");
-    DataSource dataSource = ms.getDataSource();
-
-    Connection connection = dataSource.getConnection();
-    PreparedStatement statement = connection.prepareStatement("select next VALUE for j2_seq");
-    ResultSet resultSet = statement.executeQuery();
-    if (resultSet.next()) {
-      Object val = resultSet.getObject(1);
-      System.out.println(""+val);
-    }
-    connection.close();
-  }
-}
diff --git a/ebean-core/src/test/java/org/MainMemoryLeak.java b/ebean-core/src/test/java/org/MainMemoryLeak.java
deleted file mode 100644
index b659297b4..000000000
--- a/ebean-core/src/test/java/org/MainMemoryLeak.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package org;
-
-import io.ebean.Database;
-import io.ebean.DatabaseFactory;
-import io.ebean.Transaction;
-import io.ebean.annotation.Cache;
-import io.ebean.config.DatabaseConfig;
-import io.ebean.config.PlatformNoGeneratedKeysTest;
-
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Lob;
-import java.util.Arrays;
-
-/**
- *
- * Test preparation:
- *
- * - Enable file based H2 in ebean.properties (line `datasource.h2.databaseUrl=jdbc:h2:file:~/tests`)
- * - disable logging of io.ebean.SUM/TXN/SQL in logback-test.xml
- * - remove existing database in ~/tests (do that before each run)
- * - run this class with `-Xmx1g` jvm argument
- * - an OOM in iteration ~45000 will occur (45k * 10k chars = 45k * 20k bytes = 900MB)
- *
- * remove the line `@Cache(enableQueryCache=true)` - and it will run forever (until disk is full)
- */
-public class MainMemoryLeak {
-
-  @Cache(enableQueryCache=true)
-  @Entity
-  public static class ECachedBean {
-    @Id
-    private Long id;
-
-    @Lob
-    private String description;
-  }
-
-  public static void main(String[] args) {
-
-    PlatformNoGeneratedKeysTest.OtherH2Platform platform = new PlatformNoGeneratedKeysTest.OtherH2Platform();
-
-    DatabaseConfig config = new DatabaseConfig();
-
-    config.setDatabasePlatform(platform);
-    config.addClass(ECachedBean.class);
-    config.loadFromProperties();
-
-    Database server1 = DatabaseFactory.create(config);
-    assert server1 != null;
-
-    // create again for #2193
-    Database server = DatabaseFactory.create(config);
-    assert server != null;
-
-    // create a string with 10k chars
-    char[] c = new char[10_000];
-    Arrays.fill(c, 'x');
-
-    try (Transaction txn = server.beginTransaction()) {
-      for (int i = 0; i < 500000; i++) {
-
-        if (i % 1000 == 0) {
-          long mem = Runtime.getRuntime().freeMemory() / 1024 / 1024;
-          if (mem > 1024) {
-            throw new IllegalStateException("-Xmx1g JVM argument expected");
-          }
-          System.out.println("Iteration: " + i + " Free mem: " + mem + " MB");
-        }
-
-        ECachedBean a = new ECachedBean();
-        a.description = new String(c);
-        server.save(a);
-      }
-      System.out.println("Success, no mem limit detected");
-      txn.commit();
-    }
-    server.shutdown();
-  }
-}
diff --git a/ebean-core/src/test/java/org/ebeantest/LoggedSqlCollector.java b/ebean-core/src/test/java/org/ebeantest/LoggedSqlCollector.java
deleted file mode 100644
index d80253edf..000000000
--- a/ebean-core/src/test/java/org/ebeantest/LoggedSqlCollector.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package org.ebeantest;
-
-import io.ebeantest.LoggedSql;
-
-import java.util.List;
-
-/**
- * Helper that can collect the SQL that is logged via SLF4J.
- * <p>
- * Used {@link #start()} and {@link #stop()} to collect the logged messages that contain the
- * executed SQL statements.
- * <p>
- * Internally this uses a Logback Appender to collect messages for org.avaje.ebean.SQL.
- */
-public class LoggedSqlCollector {
-
-  /**
-   * Start collection of the logged SQL statements.
-   */
-  public static List<String> start() {
-    return LoggedSql.start();
-  }
-
-  /**
-   * Stop collection of the logged SQL statements return the list of captured messages that contain
-   * the SQL.
-   */
-  public static List<String> stop() {
-    return LoggedSql.stop();
-  }
-
-  public static List<String> current() {
-    return LoggedSql.collect();
-  }
-
-}
diff --git a/ebean-core/src/test/java/org/tests/basic/TestBeanReferenceRefresh.java b/ebean-core/src/test/java/org/tests/basic/TestBeanReferenceRefresh.java
deleted file mode 100644
index 4827e46f0..000000000
--- a/ebean-core/src/test/java/org/tests/basic/TestBeanReferenceRefresh.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package org.tests.basic;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.cache.ServerCache;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.Order.Status;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.sql.Date;
-
-public class TestBeanReferenceRefresh extends BaseTestCase {
-
-  @Test
-  public void testMe() {
-
-    ResetBasicData.reset();
-
-    ServerCache beanCache = Ebean.getServerCacheManager().getBeanCache(Order.class);
-    beanCache.clear();
-
-    Order order = Ebean.getReference(Order.class, 1);
-
-    Assert.assertTrue(Ebean.getBeanState(order).isReference());
-
-    // invoke lazy loading
-    Date orderDate = order.getOrderDate();
-    Assert.assertNotNull(orderDate);
-
-    Customer customer = order.getCustomer();
-    Assert.assertNotNull(customer);
-
-    Assert.assertFalse(Ebean.getBeanState(order).isReference());
-    Assert.assertNotNull(order.getStatus());
-    Assert.assertNotNull(order.getDetails());
-    Assert.assertNull(Ebean.getBeanState(order).getLoadedProps());
-
-    Status status = order.getStatus();
-    Assert.assertTrue(status != Order.Status.SHIPPED);
-    order.setStatus(Order.Status.SHIPPED);
-    Ebean.refresh(order);
-
-    Status statusRefresh = order.getStatus();
-    Assert.assertEquals(status, statusRefresh);
-
-  }
-
-
-}
diff --git a/ebean-core/src/test/java/org/tests/basic/delete/TestDeleteByIdList.java b/ebean-core/src/test/java/org/tests/basic/delete/TestDeleteByIdList.java
deleted file mode 100644
index 7cc33ffc8..000000000
--- a/ebean-core/src/test/java/org/tests/basic/delete/TestDeleteByIdList.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package org.tests.basic.delete;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebeaninternal.api.SpiEbeanServer;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.OrderDetail;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.List;
-
-public class TestDeleteByIdList extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    ResetBasicData.reset();
-
-    OrderDetail dummy = Ebean.getReference(OrderDetail.class, 1);
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
-    server.getBeanDescriptor(OrderDetail.class).cacheBeanPut(dummy);
-
-    Customer c0 = ResetBasicData.createCustAndOrder("DelIdList-0");
-    Assert.assertNotNull(c0);
-
-    Customer c1 = ResetBasicData.createCustAndOrder("DelIdList-1");
-
-    List<Object> orderIds = Ebean.find(Order.class).where().in("customer", c0, c1).findIds();
-
-    Assert.assertEquals(2, orderIds.size());
-
-    Ebean.deleteAll(Order.class, orderIds);
-    Ebean.delete(c0);
-    Ebean.delete(c1);
-
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/basic/delete/TestDeleteCascadeById.java b/ebean-core/src/test/java/org/tests/basic/delete/TestDeleteCascadeById.java
deleted file mode 100644
index 97511df79..000000000
--- a/ebean-core/src/test/java/org/tests/basic/delete/TestDeleteCascadeById.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package org.tests.basic.delete;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebeaninternal.api.SpiEbeanServer;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.OrderDetail;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.List;
-
-public class TestDeleteCascadeById extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    ResetBasicData.reset();
-
-    OrderDetail dummy = Ebean.getReference(OrderDetail.class, 1);
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
-    server.getBeanDescriptor(OrderDetail.class).cacheBeanPut(dummy);
-
-    Customer cust = ResetBasicData.createCustAndOrder("DelCas");
-    Assert.assertNotNull(cust);
-
-    List<Order> orders = Ebean.find(Order.class).where().eq("customer", cust).findList();
-
-    Assert.assertEquals(1, orders.size());
-    Order o = orders.get(0);
-    Assert.assertNotNull(o);
-
-    // cleanup
-    Ebean.delete(o);
-    Ebean.delete(cust);
-
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestQueryJoin.java b/ebean-core/src/test/java/org/tests/batchload/TestQueryJoin.java
deleted file mode 100644
index 533dd5470..000000000
--- a/ebean-core/src/test/java/org/tests/batchload/TestQueryJoin.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package org.tests.batchload;
-
-import io.ebean.BaseTestCase;
-import io.ebean.BeanState;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import io.ebean.cache.ServerCache;
-import org.tests.model.basic.Address;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.List;
-
-public class TestQueryJoin extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    ResetBasicData.reset();
-
-    // Need to make sure the customer cache is cleared for the later
-    // asserts on the lazy loading
-    ServerCache custCache = Ebean.getServerCacheManager().getBeanCache(Customer.class);
-    custCache.clear();
-
-    Query<Order> query = Ebean.find(Order.class).select("status")
-      // .join("details","+query(10)")
-      .fetchLazy("customer", "name, status").fetch("customer.contacts").order().asc("id");
-    // .join("customer.billingAddress");
-
-    List<Order> list = query.findList();
-
-    // list.get(0).getShipDate();
-
-    Order order = list.get(0);
-    BeanState beanStateOrder = Ebean.getBeanState(order);
-    Assert.assertNotNull(beanStateOrder.getLoadedProps());
-    // Assert.assertTrue(beanStateOrder.getLoadedProps().contains("id"));
-    Assert.assertTrue(beanStateOrder.getLoadedProps().contains("status"));
-    Assert.assertTrue(beanStateOrder.getLoadedProps().contains("shipments"));
-    Assert.assertTrue(beanStateOrder.getLoadedProps().contains("customer"));
-
-    Customer customer = order.getCustomer();
-    BeanState beanStateCustomer = Ebean.getBeanState(customer);
-    Assert.assertTrue(beanStateCustomer.isReference());
-
-    customer.getName();
-    Assert.assertNotNull(beanStateCustomer.getLoadedProps());
-    Assert.assertTrue(beanStateCustomer.getLoadedProps().contains("name"));
-    Assert.assertTrue(beanStateCustomer.getLoadedProps().contains("status"));
-    Assert.assertFalse(beanStateCustomer.getLoadedProps().contains("billingAddress"));
-
-    customer.getName();
-
-    Address billingAddress = customer.getBillingAddress();
-    System.out.println(billingAddress);
-    billingAddress.getLine1();
-
-    Assert.assertTrue(!list.isEmpty());
-
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/cache/TestBeanCacheWithDeleteQuery.java b/ebean-core/src/test/java/org/tests/cache/TestBeanCacheWithDeleteQuery.java
deleted file mode 100644
index ffb88f150..000000000
--- a/ebean-core/src/test/java/org/tests/cache/TestBeanCacheWithDeleteQuery.java
+++ /dev/null
@@ -1,82 +0,0 @@
-package org.tests.cache;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
-import org.tests.model.basic.OCachedBean;
-
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-
-/**
- * Test class testing clearing cache with delete query
- */
-public class TestBeanCacheWithDeleteQuery extends BaseTestCase {
-
-  @Test
-  public void testBeanCacheGetsClearedOnDelete() {
-
-    OCachedBean bean = new OCachedBean();
-    bean.setName("cache-invalidation");
-    Ebean.save(bean);
-
-    OCachedBean bean0 = Ebean.find(OCachedBean.class, bean.getId());
-    assertNotNull(bean0);
-
-    // expect to hit the cache, no SQL
-    LoggedSqlCollector.start();
-    OCachedBean bean1 = Ebean.find(OCachedBean.class, bean.getId());
-    List<String> sql = LoggedSqlCollector.stop();
-    assertNotNull(bean1);
-    assertThat(sql).isEmpty();
-
-    // delete the bean
-    int deleted = Ebean.createQuery(OCachedBean.class).where().eq("name", "cache-invalidation").delete();
-
-    assertEquals(deleted, 1);
-
-    // expect not to hit the cache, expect SQL
-    LoggedSqlCollector.start();
-    OCachedBean bean2 = Ebean.find(OCachedBean.class).setReadOnly(true).setId(String.valueOf(bean.getId())).findOne();
-    sql = LoggedSqlCollector.stop();
-    assertNull(bean2);
-    assertThat(sql).isNotEmpty();
-  }
-
-  @Test
-  public void testBeanCacheGetsClearedOnUpdate() {
-
-    OCachedBean bean = new OCachedBean();
-    bean.setName("cache-invalidation-upd");
-    Ebean.save(bean);
-
-    OCachedBean bean0 = Ebean.find(OCachedBean.class, bean.getId());
-    assertNotNull(bean0);
-
-    // expect to hit the cache, no SQL
-    LoggedSqlCollector.start();
-    OCachedBean bean1 = Ebean.find(OCachedBean.class, bean.getId());
-    List<String> sql = LoggedSqlCollector.stop();
-    assertNotNull(bean1);
-    assertThat(sql).isEmpty();
-
-    // update the bean
-    int updated = Ebean.update(OCachedBean.class).set("name", "updatedName").where().eq("name","cache-invalidation-upd").update();
-
-    assertEquals(updated, 1);
-
-    // expect not to hit the cache, expect SQL
-    LoggedSqlCollector.start();
-    OCachedBean bean2 = Ebean.find(OCachedBean.class).setReadOnly(true).setId(String.valueOf(bean.getId())).findOne();
-    sql = LoggedSqlCollector.stop();
-    assertNotNull(bean2);
-    assertThat(sql).isNotEmpty();
-    assertEquals("updatedName", bean2.getName());
-  }
-
-}
diff --git a/ebean-core/src/test/java/org/tests/cache/TestCacheBasic.java b/ebean-core/src/test/java/org/tests/cache/TestCacheBasic.java
deleted file mode 100644
index 390e3e4e4..000000000
--- a/ebean-core/src/test/java/org/tests/cache/TestCacheBasic.java
+++ /dev/null
@@ -1,146 +0,0 @@
-package org.tests.cache;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.cache.ServerCache;
-import io.ebean.cache.ServerCacheStatistics;
-import org.tests.model.basic.Country;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
-
-public class TestCacheBasic extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    ResetBasicData.reset();
-
-    Ebean.getServerCacheManager().clear(Country.class);
-    ServerCache countryCache = Ebean.getServerCacheManager().getBeanCache(Country.class);
-
-    loadCountryCache();
-    Assert.assertTrue(countryCache.size() > 0);
-
-    // reset the statistics
-    countryCache.getStatistics(true);
-
-    Country c0 = Ebean.getReference(Country.class, "NZ");
-    ServerCacheStatistics statistics = countryCache.getStatistics(false);
-    long hc = statistics.getHitCount();
-    Assert.assertEquals(1, hc);
-    Assert.assertNotNull(c0);
-
-    // Country c1 = Ebean.getReference(Country.class, "NZ");
-    // Assert.assertEquals(2, countryCache.getStatistics(false).getHitCount());
-    // //Assert.assertEquals(100,
-    // countryCache.getStatistics(false).getHitRatio());
-    //
-    // // same instance as caching with readOnly=true
-    // Assert.assertTrue(c0 != c1);
-    //
-    // c0.getName();
-    // c1.getName();
-    //
-    // // reset the statistics
-    // Assert.assertEquals(2,countryCache.getStatistics(true).getHitCount());
-    // // now the count should be 0 again
-    // Assert.assertEquals(0, countryCache.getStatistics(false).getHitCount());
-    // // and hitRatio is 0 as well
-    // Assert.assertEquals(0, countryCache.getStatistics(false).getHitRatio());
-    //
-    // // hit the country cache automatically via join
-    //
-    // Customer custTest = ResetBasicData.createCustAndOrder("cacheBasic");
-    // Integer id = custTest.getId();
-    // Customer customer = Ebean.find(Customer.class, id);
-    //
-    // Address billingAddress = customer.getBillingAddress();
-    // Country c2 = billingAddress.getCountry();
-    // c2.getName();
-    //
-    // Assert.assertTrue(countryCache.getStatistics(false).getHitCount() > 0);
-    //
-    // //Country c3 = Ebean.getReference(Country.class, "NZ");
-    // //Country c4 = Ebean.find(Country.class, "NZ");
-    //
-    //
-    // // clear the cache
-    // Ebean.getServerCacheManager().clear(Country.class);
-    // // reset statistics
-    // countryCache.getStatistics(true);
-    //
-    // // try to hit the country cache automatically via join
-    // customer = Ebean.find(Customer.class, id);
-    // billingAddress = customer.getBillingAddress();
-    // Country c5 = billingAddress.getCountry();
-    // // but cache is empty so c5 is reference that will load cache
-    // // if it is lazy loaded
-    // Assert.assertEquals("empty cache",0,countryCache.getStatistics(false).getSize());
-    // //Assert.assertEquals("missCount 1",1,countryCache.getStatistics(false).getMissCount());
-    //
-    // // lazy load on c5 populates the cache
-    // c5.getName();
-    // Assert.assertEquals("cache populated via lazy load",1,countryCache.getStatistics(false).getSize());
-    //
-    // // now these get hits in the cache
-    // Country c6 = Ebean.find(Country.class, "NZ");
-    //
-    // Assert.assertTrue("different instance as cache cleared",c2 != c5);
-    // Assert.assertTrue("these 2 are different",c5 != c6);
-    //
-    // // by default readOnly based on deployment annotation
-    // Assert.assertTrue("read only",Ebean.getBeanState(c6).isReadOnly());
-    //
-    // try {
-    // // can't modify a readOnly bean
-    // c6.setName("Nu Zilund");
-    // Assert.assertFalse("Never get here",true);
-    // } catch (IllegalStateException e){
-    // Assert.assertTrue("This is readOnly",true);
-    // }
-    //
-    // Country c8 = Ebean.find(Country.class)
-    // .setId("NZ")
-    // .setReadOnly(false)
-    // .findOne();
-    //
-    // // Explicitly NOT readOnly
-    // Assert.assertFalse("NOT read only",Ebean.getBeanState(c8).isReadOnly());
-    //
-    // Assert.assertEquals("1 countries in cache", 1, countryCache.size());
-    // c8.setName("Nu Zilund");
-    // // the update will remove the entry from the cache
-    // Ebean.save(c8);
-    //
-    // Assert.assertEquals("1 country in cache", 1, countryCache.size());
-    //
-    // Country c9 = Ebean.find(Country.class)
-    // .setReadOnly(false)
-    // .setId("NZ")
-    // .findOne();
-    //
-    // // Find loads cache ...
-    // Assert.assertFalse(Ebean.getBeanState(c9).isReadOnly());
-    // Assert.assertTrue(countryCache.size() > 0);
-    //
-    // Country c10 = Ebean.find(Country.class,"NZ");
-    //
-    // Assert.assertTrue(Ebean.getBeanState(c10).isReadOnly());
-    // Assert.assertTrue(countryCache.size() > 0);
-    //
-    // Ebean.getServerCacheManager().clear(Country.class);
-    // Assert.assertEquals("0 country in cache", 0, countryCache.size());
-    //
-    // // reference doesn't load cache yet
-    // Country c11 = Ebean.getReference(Country.class, "NZ");
-    //
-    // // still 0 in cache
-    // Assert.assertEquals("0 country in cache", 0, countryCache.size());
-    //
-    // // will invoke lazy loading..
-    // c11.getName();
-    // Assert.assertTrue(countryCache.size() > 0);
-
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/el/TestELBasic.java b/ebean-core/src/test/java/org/tests/el/TestELBasic.java
deleted file mode 100644
index b58a75438..000000000
--- a/ebean-core/src/test/java/org/tests/el/TestELBasic.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package org.tests.el;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebeaninternal.api.SpiEbeanServer;
-import io.ebeaninternal.server.deploy.BeanDescriptor;
-import io.ebeaninternal.server.deploy.BeanFkeyProperty;
-import io.ebeaninternal.server.deploy.BeanProperty;
-import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
-import io.ebeaninternal.server.deploy.BeanPropertyAssocOne;
-import io.ebeaninternal.server.el.ElPropertyChain;
-import io.ebeaninternal.server.el.ElPropertyDeploy;
-import org.tests.model.basic.Customer;
-import org.junit.Assert;
-import org.junit.Test;
-
-public class TestELBasic extends BaseTestCase {
-
-  @Test
-  public void testEl() {
-
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
-    BeanDescriptor<Customer> descriptor = server.getBeanDescriptor(Customer.class);
-
-    ElPropertyDeploy elId = descriptor.getElPropertyDeploy("id");
-    Assert.assertTrue(elId instanceof BeanProperty);
-
-    ElPropertyDeploy elBillAddress = descriptor.getElPropertyDeploy("billingAddress");
-    Assert.assertTrue(elBillAddress instanceof BeanPropertyAssocOne<?>);
-
-    ElPropertyDeploy elBillAddressId = descriptor.getElPropertyDeploy("billingAddress.id");
-    Assert.assertTrue(elBillAddressId instanceof BeanFkeyProperty);
-    Assert.assertEquals("billing_address_id", elBillAddressId.getDbColumn());
-    Assert.assertEquals("billingAddress.id", elBillAddressId.getName());
-    Assert.assertNull(elBillAddressId.getElPrefix());
-
-
-    ElPropertyDeploy elBillAddressCity = descriptor.getElPropertyDeploy("billingAddress.city");
-    Assert.assertTrue(elBillAddressCity instanceof ElPropertyChain);
-    Assert.assertEquals("billingAddress", elBillAddressCity.getElPrefix());
-    Assert.assertEquals("city", elBillAddressCity.getName());
-    Assert.assertEquals("${billingAddress}city", elBillAddressCity.getElPlaceholder(false));
-    Assert.assertEquals("city", elBillAddressCity.getDbColumn());
-
-//		ElPropertyDeploy elBillAddressCountry = descriptor.getElPropertyDeploy("billingAddress.country");
-
-
-    ElPropertyDeploy elOrders = descriptor.getElPropertyDeploy("orders");
-    Assert.assertTrue(elOrders instanceof BeanPropertyAssocMany<?>);
-
-    ElPropertyDeploy elOrderStatus = descriptor.getElPropertyDeploy("orders.status");
-    Assert.assertTrue(elOrderStatus instanceof ElPropertyChain);
-    Assert.assertEquals("orders", elOrderStatus.getElPrefix());
-    Assert.assertEquals("status", elOrderStatus.getName());
-    Assert.assertEquals("${orders}status", elOrderStatus.getElPlaceholder(false));
-    Assert.assertEquals("status", elOrderStatus.getDbColumn());
-
-    ElPropertyDeploy elOrderCust = descriptor.getElPropertyDeploy("orders.customer");
-    Assert.assertTrue(elOrderCust instanceof ElPropertyChain);
-
-    ElPropertyDeploy elOrderDetails = descriptor.getElPropertyDeploy("orders.details");
-    Assert.assertTrue(elOrderDetails instanceof ElPropertyChain);
-
-    ElPropertyDeploy elOrderDetailsId = descriptor.getElPropertyDeploy("orders.details.id");
-    Assert.assertTrue(elOrderDetailsId instanceof ElPropertyChain);
-
-  }
-
-
-}
diff --git a/ebean-core/src/test/java/org/tests/insert/TestInsertCollection.java b/ebean-core/src/test/java/org/tests/insert/TestInsertCollection.java
deleted file mode 100644
index 87b5d98cf..000000000
--- a/ebean-core/src/test/java/org/tests/insert/TestInsertCollection.java
+++ /dev/null
@@ -1,81 +0,0 @@
-package org.tests.insert;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.tests.model.basic.Customer;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class TestInsertCollection extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    Customer cust1 = new Customer();
-    cust1.setName("jim");
-
-    Customer cust2 = new Customer();
-    cust2.setName("bob");
-
-    List<Customer> customers = new ArrayList<>();
-    customers.add(cust1);
-    customers.add(cust2);
-
-    Ebean.insertAll(customers);
-
-    Assert.assertNotNull(cust1.getId());
-    Assert.assertNotNull(cust2.getId());
-
-    Customer cust1Check = Ebean.find(Customer.class, cust1.getId());
-    Assert.assertEquals(cust1.getName(), cust1Check.getName());
-    Customer cust2Check = Ebean.find(Customer.class, cust2.getId());
-    Assert.assertEquals(cust2.getName(), cust2Check.getName());
-
-    cust1.setName("jim-changed");
-    cust2.setName("bob-changed");
-
-    Ebean.updateAll(customers);
-    awaitL2Cache();
-
-    Customer cust1Check2 = Ebean.find(Customer.class, cust1.getId());
-    Assert.assertEquals("jim-changed", cust1Check2.getName());
-    Customer cust2Check2 = Ebean.find(Customer.class, cust2.getId());
-    Assert.assertEquals("bob-changed", cust2Check2.getName());
-
-
-    cust1Check2.setName("jim-updated");
-    Customer cust3 = new Customer();
-    cust3.setName("mac");
-
-    List<Customer> saveList = new ArrayList<>();
-    saveList.add(cust1Check2);
-    saveList.add(cust3);
-
-    Ebean.saveAll(saveList);
-    awaitL2Cache();
-
-
-    Customer cust1Check3 = Ebean.find(Customer.class, cust1.getId());
-    Assert.assertEquals("jim-updated", cust1Check3.getName());
-    Customer cust3Check = Ebean.find(Customer.class, cust3.getId());
-    Assert.assertEquals("mac", cust3Check.getName());
-
-    List<Customer> deleteList = new ArrayList<>();
-    deleteList.add(cust1Check3);
-    deleteList.add(cust3);
-    deleteList.add(cust2Check2);
-
-    Ebean.deleteAll(deleteList);
-    awaitL2Cache();
-
-    Assert.assertNull(Ebean.find(Customer.class, cust1Check3.getId()));
-    Assert.assertNull(Ebean.find(Customer.class, cust2Check2.getId()));
-    Assert.assertNull(Ebean.find(Customer.class, cust3.getId()));
-
-  }
-
-
-}
diff --git a/ebean-core/src/test/java/org/tests/iud/TestInsertUpdateTrans.java b/ebean-core/src/test/java/org/tests/iud/TestInsertUpdateTrans.java
deleted file mode 100644
index 32dc30f16..000000000
--- a/ebean-core/src/test/java/org/tests/iud/TestInsertUpdateTrans.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package org.tests.iud;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.Transaction;
-import org.junit.Assert;
-import org.junit.Test;
-import org.tests.model.basic.EBasicVer;
-
-public class TestInsertUpdateTrans extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    try (Transaction txn = Ebean.beginTransaction()) {
-
-      EBasicVer e0 = new EBasicVer("onInsert");
-      e0.setDescription("something");
-      Ebean.save(e0);
-
-      Assert.assertNotNull(e0.getId());
-      Assert.assertNotNull(e0.getLastUpdate());
-      Assert.assertEquals("onInsert", e0.getName());
-
-      e0.setName("onUpdate");
-      e0.setDescription("differentFromInsert");
-
-      Ebean.save(e0);
-
-      EBasicVer e1 = Ebean.find(EBasicVer.class, e0.getId());
-
-      // we should fetch back the updated data (not inserted)
-      Assert.assertEquals(e0.getId(), e1.getId());
-      Assert.assertEquals("onUpdate", e1.getName());
-      Assert.assertEquals("differentFromInsert", e1.getDescription());
-
-      txn.commit();
-    }
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteObjectWithCascadeToM2m.java b/ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteObjectWithCascadeToM2m.java
deleted file mode 100644
index b5a8f5137..000000000
--- a/ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteObjectWithCascadeToM2m.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package org.tests.m2m;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.tests.model.m2m.Permission;
-import org.tests.model.m2m.Role;
-import org.tests.model.m2m.Tenant;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-public class TestM2MDeleteObjectWithCascadeToM2m extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    Ebean.createUpdate(Permission.class, "delete from Permission").execute();
-    Ebean.createUpdate(Tenant.class, "delete from Tenant").execute();
-    Ebean.createUpdate(Role.class, "delete from Role").execute();
-
-    Tenant tenant1 = new Tenant("Tenant");
-    Ebean.save(tenant1);
-
-    Permission p1 = new Permission("p1");
-    Permission p2 = new Permission("p2");
-    Ebean.save(p1);
-    Ebean.save(p2);
-
-    Role role1 = new Role("RoleOne");
-    role1.setTenant(tenant1);
-
-    Set<Permission> permissions = new HashSet<>();
-    List<Permission> permsList = Ebean.find(Permission.class).findList();
-    permissions.addAll(permsList);
-
-    role1.setPermissions(permissions);
-
-    Ebean.save(role1);
-
-
-    List<Tenant> tenantList = Ebean.find(Tenant.class).fetch("roles").findList();
-    List<Role> roleList = Ebean.find(Role.class).fetch("permissions").findList();
-    List<Permission> permissionList = Ebean.find(Permission.class).fetch("roles").findList();
-
-    Assert.assertEquals(1, tenantList.size());
-    Assert.assertEquals(2, permissionList.size());
-    Assert.assertEquals(1, roleList.size());
-
-    Ebean.delete(tenant1);
-
-    List<Tenant> tenantList2 = Ebean.find(Tenant.class).fetch("roles").findList();
-    List<Role> roleList2 = Ebean.find(Role.class).fetch("permissions").findList();
-    List<Permission> permissionList2 = Ebean.find(Permission.class).fetch("roles").findList();
-
-    Assert.assertEquals(0, tenantList2.size());
-    Assert.assertEquals(0, roleList2.size());
-    Assert.assertEquals(2, permissionList2.size());
-
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/m2m/TestM2mDeleteObject.java b/ebean-core/src/test/java/org/tests/m2m/TestM2mDeleteObject.java
deleted file mode 100644
index 3ccad9fb8..000000000
--- a/ebean-core/src/test/java/org/tests/m2m/TestM2mDeleteObject.java
+++ /dev/null
@@ -1,94 +0,0 @@
-package org.tests.m2m;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.meta.MetaTimedMetric;
-import org.junit.Assert;
-import org.junit.Test;
-import org.tests.model.m2m.Permission;
-import org.tests.model.m2m.Role;
-import org.tests.model.m2m.Tenant;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class TestM2mDeleteObject extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    resetAllMetrics();
-
-    Ebean.createUpdate(Permission.class, "delete from Permission").setLabel("deleteAllPermissions").execute();
-    Ebean.createUpdate(Tenant.class, "delete from Tenant").execute();
-    Ebean.createUpdate(Role.class, "delete from Role").execute();
-
-    List<MetaTimedMetric> sqlMetrics = sqlMetrics();
-    assertThat(sqlMetrics).hasSize(1);
-    assertThat(sqlMetrics.get(0).name()).isEqualTo("orm.update.deleteAllPermissions");
-
-    Tenant t = new Tenant("tenant");
-
-    Ebean.save(t);
-
-    Permission p1 = new Permission("p1");
-    Permission p2 = new Permission("p2");
-
-    Ebean.save(p1);
-    Ebean.save(p2);
-
-    Role role1 = new Role("role");
-    role1.setTenant(t);
-
-    Set<Permission> permissions = new HashSet<>();
-    List<Permission> permsList = Ebean.find(Permission.class).findList();
-    permissions.addAll(permsList);
-
-    role1.setPermissions(permissions);
-
-    Ebean.save(role1);
-
-    List<Tenant> tenantList = Ebean.find(Tenant.class).fetch("roles").findList();
-    List<Role> roleList = Ebean.find(Role.class).fetch("permissions").findList();
-    List<Permission> permissionList = Ebean.find(Permission.class).fetch("roles").findList();
-
-    Assert.assertEquals(1, tenantList.size());
-    Assert.assertEquals(2, permissionList.size());
-    Assert.assertEquals(1, roleList.size());
-
-    Ebean.delete(role1);
-
-    List<Tenant> tenantList2 = Ebean.find(Tenant.class).fetch("roles").findList();
-    List<Role> roleList2 = Ebean.find(Role.class).fetch("permissions").findList();
-    List<Permission> permissionList2 = Ebean.find(Permission.class).fetch("roles").findList();
-
-    Assert.assertEquals(0, roleList2.size());
-    Assert.assertEquals(1, tenantList2.size());
-    Assert.assertEquals(2, permissionList2.size());
-  }
-
-
-  @Test
-  public void test_deleteCascading() {
-
-    Permission p1 = new Permission("p1");
-    Permission p2 = new Permission("p2");
-    Ebean.save(p1);
-    Ebean.save(p2);
-
-    Role role1 = new Role("role");
-
-    Set<Permission> permissions = new HashSet<>();
-    permissions.add(p2);
-    role1.setPermissions(permissions);
-    Ebean.save(role1);
-
-    // only deletes as not associated
-    Ebean.delete(p1);
-    // delete cascades
-    Ebean.delete(role1);
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/model/uuidsibling/SoftDeleteCascadeTest.java b/ebean-core/src/test/java/org/tests/model/uuidsibling/SoftDeleteCascadeTest.java
deleted file mode 100644
index 42cfa2a62..000000000
--- a/ebean-core/src/test/java/org/tests/model/uuidsibling/SoftDeleteCascadeTest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-package org.tests.model.uuidsibling;
-
-import org.junit.Test;
-
-import java.util.UUID;
-
-import static org.hamcrest.core.Is.is;
-import static org.hamcrest.core.IsNot.not;
-import static org.hamcrest.core.IsNull.nullValue;
-import static org.junit.Assert.assertThat;
-
-public class SoftDeleteCascadeTest {
-
-  @Test
-  public void testDeleteParent() {
-    // Insert + link records
-    USibParent parent = new USibParent();
-    parent.save();
-
-    USibChild child = new USibChild(parent);
-    child.save();
-
-    USibChildSibling childSibling = new USibChildSibling(child);
-    childSibling.save();
-
-    Long parentId = parent.getId();
-    UUID childId = child.getId();
-    Long childSiblingId = childSibling.getId();
-
-    assertBefore(parent, child, childSibling);
-    parent.delete();
-    assertAfter(parentId, childId, childSiblingId);
-  }
-
-  private void assertBefore(USibParent parent, USibChild child, USibChildSibling childSibling) {
-
-    parent.refresh();
-
-    assertThat("Parent should have one child loaded",
-      parent.getChildren().size(),
-      is(1)
-    );
-
-    assertThat("Parent should have correct child loaded",
-      parent.getChildren().get(0).getId(),
-      is(child.getId())
-    );
-
-    assertThat("Child that was loaded should have its sibling available",
-      parent.getChildren().get(0).getChildSibling(),
-      not(nullValue())
-    );
-
-    assertThat(
-      "Child that was loaded should have loaded correct sibling",
-      parent.getChildren().get(0).getChildSibling().getId(),
-      is(childSibling.getId())
-    );
-  }
-
-  private void assertAfter(Long parentId, UUID childId, Long childSiblingId) {
-    assertThat(USibParent.find.byId(parentId), is(nullValue()));
-    assertThat(USibChild.find.byId(childId), is(nullValue()));
-    assertThat(USibChildSibling.find.byId(childSiblingId), is(nullValue()));
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/o2o/TestReferenceSave.java b/ebean-core/src/test/java/org/tests/o2o/TestReferenceSave.java
deleted file mode 100644
index 11d3bd9f2..000000000
--- a/ebean-core/src/test/java/org/tests/o2o/TestReferenceSave.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package org.tests.o2o;
-
-
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
-import org.tests.update.EPersonOnline;
-
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class TestReferenceSave {
-
-  @Test
-  public void test() {
-
-    Ebean.getDefaultServer();
-
-    LoggedSqlCollector.start();
-
-    EPersonOnline bean = Ebean.getReference(EPersonOnline.class, 1L);
-    Ebean.save(bean);
-
-    List<String> sql = LoggedSqlCollector.current();
-    assertThat(sql).hasSize(0);
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/query/TestDefaultFetchLazy.java b/ebean-core/src/test/java/org/tests/query/TestDefaultFetchLazy.java
deleted file mode 100644
index dffdadb96..000000000
--- a/ebean-core/src/test/java/org/tests/query/TestDefaultFetchLazy.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package org.tests.query;
-
-import io.ebean.BaseTestCase;
-import io.ebean.BeanState;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import org.tests.model.basic.MyLobSize;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.Set;
-
-public class TestDefaultFetchLazy extends BaseTestCase {
-
-  @Test
-  public void testFetchTypeLazy() {
-
-    MyLobSize m = new MyLobSize();
-    m.setName("aname");
-    m.setMyCount(10);
-    m.setMyLob("A big lob of data");
-
-    Ebean.save(m);
-
-    Assert.assertNotNull(m.getId());
-
-    MyLobSize myLobSize = Ebean.find(MyLobSize.class, m.getId());
-
-    BeanState beanState = Ebean.getBeanState(myLobSize);
-    Set<String> loadedProps = beanState.getLoadedProps();
-
-    Assert.assertNotNull(loadedProps);
-    Assert.assertTrue(loadedProps.contains("id"));
-    Assert.assertTrue(loadedProps.contains("name"));
-
-    // FetchType.LAZY properties excluded
-    Assert.assertFalse(loadedProps.contains("myLob"));
-    Assert.assertFalse(loadedProps.contains("myCount"));
-
-    // the details is also tuned
-    Query<MyLobSize> queryMany = Ebean.find(MyLobSize.class).fetch("details")// ,"+query")
-      .where().gt("id", 0).query();
-
-    queryMany.findList();
-
-    String generatedSql = queryMany.getGeneratedSql();
-    Assert.assertTrue(generatedSql.contains("t1.other"));
-    Assert.assertFalse(generatedSql.contains("t1.something"));
-  }
-
-}
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFindReadOnly.java b/ebean-core/src/test/java/org/tests/query/TestQueryFindReadOnly.java
deleted file mode 100644
index 5df8231fc..000000000
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFindReadOnly.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package org.tests.query;
-
-import io.ebean.BaseTestCase;
-import io.ebean.CacheMode;
-import io.ebean.Ebean;
-import org.junit.Assert;
-import org.junit.Test;
-import org.tests.model.basic.Article;
-import org.tests.model.basic.Section;
-
-import java.util.List;
-
-public class TestQueryFindReadOnly extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    Section s0 = new Section("some content");
-    Article a0 = new Article("art1", "auth1");
-    a0.addSection(s0);
-
-    Ebean.save(a0);
-
-    Article ar1 = Ebean.find(Article.class).setReadOnly(true).setId(a0.getId()).findOne();
-
-    Assert.assertNotNull(ar1);
-    Assert.assertTrue("readonly", Ebean.getBeanState(ar1).isReadOnly());
-
-    List<Section> ar1sections = ar1.getSections();
-    Assert.assertEquals(1, ar1sections.size());
-
-    Section s2 = ar1sections.get(0);
-    Assert.assertTrue("readonly cascading", Ebean.getBeanState(s2).isReadOnly());
-
-    Ebean.find(Article.class).setBeanCacheMode(CacheMode.PUT).findList();
-
-    Article ar0 = Ebean.find(Article.class, a0.getId());
-
-    Assert.assertNotNull(ar0);
-    Assert.assertFalse(Ebean.getBeanState(ar0).isReadOnly());
-
-    List<Section> ar0sections = ar0.getSections();
-    Section s1 = ar0sections.get(0);
-    Assert.assertFalse(Ebean.getBeanState(s1).isReadOnly());
-
-  }
-
-}
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryMultiManyOrder.java b/ebean-core/src/test/java/org/tests/query/TestQueryMultiManyOrder.java
deleted file mode 100644
index 674cf07e9..000000000
--- a/ebean-core/src/test/java/org/tests/query/TestQueryMultiManyOrder.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package org.tests.query;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.List;
-
-public class TestQueryMultiManyOrder extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    ResetBasicData.reset();
-
-    Query<Order> q = Ebean.find(Order.class).fetch("shipments").fetch("details")
-      .fetch("details.product").fetch("customer").where().gt("id", 0).query();
-
-    List<Order> list = q.findList();
-    String sql = q.getGeneratedSql();
-
-    Assert.assertTrue(!list.isEmpty());
-    Assert.assertTrue(sql.contains("join o_customer "));
-
-    Assert.assertFalse(sql.contains("left join contact "));
-    Assert.assertFalse(sql.contains("left join o_order_detail "));
-    Assert.assertFalse(sql.contains("left join o_product "));
-
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryNullAssocOne.java b/ebean-core/src/test/java/org/tests/query/TestQueryNullAssocOne.java
deleted file mode 100644
index d47143442..000000000
--- a/ebean-core/src/test/java/org/tests/query/TestQueryNullAssocOne.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package org.tests.query;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.List;
-
-public class TestQueryNullAssocOne extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    ResetBasicData.reset();
-
-    Query<Order> q0 = Ebean.find(Order.class).where().eq("customer", null).query();
-
-    List<Order> orders = q0.findList();
-    Assert.assertNotNull(orders);
-    Assert.assertTrue(q0.getGeneratedSql().contains("where t0.kcustomer_id is null"));
-
-    Query<Order> q1 = Ebean.find(Order.class).where().eq("customer.id", null).query();
-
-    List<Order> o1 = q1.findList();
-    Assert.assertTrue(o1.size() == orders.size());
-    Assert.assertTrue(q1.getGeneratedSql().contains("where t0.kcustomer_id is null"));
-
-    Query<Order> q2 = Ebean.find(Order.class).where().isNull("customer").query();
-
-    List<Order> o2 = q2.findList();
-    Assert.assertTrue(o2.size() == orders.size());
-    Assert.assertTrue(q2.getGeneratedSql().contains("where t0.kcustomer_id is null"));
-
-    Query<Order> q3 = Ebean.find(Order.class).where().isNull("customer").query();
-
-    List<Order> o3 = q3.findList();
-    Assert.assertTrue(o3.size() == orders.size());
-    Assert.assertTrue(q3.getGeneratedSql().contains("where t0.kcustomer_id is null"));
-
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/query/embedded/TestFilteringByEmbeddedInJoinedTable.java b/ebean-core/src/test/java/org/tests/query/embedded/TestFilteringByEmbeddedInJoinedTable.java
deleted file mode 100644
index 263de866b..000000000
--- a/ebean-core/src/test/java/org/tests/query/embedded/TestFilteringByEmbeddedInJoinedTable.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package org.tests.query.embedded;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.ExpressionList;
-import org.hamcrest.core.Is;
-import org.junit.Assert;
-import org.junit.Test;
-import org.tests.model.embedded.EEmbDatePeriod;
-import org.tests.model.embedded.EEmbInner;
-import org.tests.model.embedded.EEmbOuter;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.util.Date;
-import java.util.List;
-
-/**
- * Test that selecting A and filtering on 'B.C=some_value' will correctly create join on table for B.
- * Model:
- * - Bean A has relation to bean B
- * - Bean B has an embedded property C
- */
-public class TestFilteringByEmbeddedInJoinedTable extends BaseTestCase {
-
-    private EEmbOuter createOuter(String nomeOuter, Date date1, Date date2) {
-        EEmbOuter outer1 = new EEmbOuter();
-        outer1.setNomeOuter(nomeOuter);
-
-        EEmbDatePeriod eEmbDatePeriod = new EEmbDatePeriod();
-        eEmbDatePeriod.setDate1(date1);
-        eEmbDatePeriod.setDate2(date2);
-        outer1.setDatePeriod(eEmbDatePeriod);
-
-        Ebean.save(outer1);
-        return outer1;
-    }
-
-    @Test
-    public void testOuterTableJoined() {
-
-        EEmbOuter outer1 = createOuter("outer1", new Date(11111), new Date(12222));
-        // Unused outer2 just to populate the DB
-        EEmbOuter outer2 = createOuter("outer2", new Date(21111), new Date(22222));
-        assertThat(outer2).isNotNull();
-
-        EEmbOuter outer3 = createOuter("outer3", new Date(31111), new Date(32222));
-
-
-        EEmbInner inner1 = new EEmbInner();
-        inner1.setOuter(outer1);
-        inner1.setNomeInner("inner1-1");
-        Ebean.save(inner1);
-
-        EEmbInner inner2 = new EEmbInner();
-        // Setting outer1 also here
-        inner2.setOuter(outer1);
-        inner2.setNomeInner("inner2-1");
-        Ebean.save(inner2);
-
-        EEmbInner inner3 = new EEmbInner();
-        inner3.setOuter(outer3);
-        inner3.setNomeInner("inner3-3");
-        Ebean.save(inner3);
-
-        ExpressionList<EEmbInner> el = Ebean.find(EEmbInner.class).where()
-                .eq("outer.datePeriod.date1", new Date(11111));
-        List<EEmbInner> list = el.findList();
-
-        Assert.assertThat(list.size(), Is.is(2));
-
-    }
-}
-
-
-
-
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonInheritance.java b/ebean-core/src/test/java/org/tests/text/json/TestTextJsonInheritance.java
deleted file mode 100644
index 288a61cc5..000000000
--- a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonInheritance.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package org.tests.text.json;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.text.json.JsonContext;
-import org.tests.model.basic.Car;
-import org.tests.model.basic.CarAccessory;
-import org.tests.model.basic.CarFuse;
-import org.tests.model.basic.Trip;
-import org.tests.model.basic.Truck;
-import org.tests.model.basic.Vehicle;
-import org.tests.model.basic.VehicleDriver;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class TestTextJsonInheritance extends BaseTestCase {
-
-  @Test
-  public void parseJson_when_inheritanceType_outOfOrderDtype() {
-
-    String fom = "{\"id\":90,\"name\":\"Frank\",\"vehicle\":{\"id\":42,\"licenseNumber\":\"T100\",\"capacity\":99.0,\"dtype\":\"T\"}}";
-
-    VehicleDriver driver1 = Ebean.json().toBean(VehicleDriver.class, fom);
-    assertThat(driver1.getVehicle()).isInstanceOf(Truck.class);
-    assertThat(driver1.getVehicle().getLicenseNumber()).isEqualTo("T100");
-  }
-
-  @Test
-  public void test() {
-
-    setupData();
-
-    List<Vehicle> list = Ebean.find(Vehicle.class).setAutoTune(false).findList();
-
-    Assert.assertEquals(2, list.size());
-
-    JsonContext jsonContext = Ebean.json();
-    String jsonString = jsonContext.toJson(list);
-
-    List<Vehicle> rebuiltList = jsonContext.toList(Vehicle.class, jsonString);
-
-    Assert.assertEquals(2, rebuiltList.size());
-
-  }
-
-  private void setupData() {
-
-    Ebean.createUpdate(CarAccessory.class, "delete from CarAccessory").execute();
-    Ebean.createUpdate(CarFuse.class, "delete from CarFuse").execute();
-    Ebean.createUpdate(Trip.class, "delete from trip").execute();
-    Ebean.createUpdate(VehicleDriver.class, "delete from vehicleDriver").execute();
-    Ebean.createUpdate(Vehicle.class, "delete from vehicle").execute();
-
-    Car c = new Car();
-    c.setLicenseNumber("C6788");
-    c.setDriver("CarDriver");
-    Ebean.save(c);
-
-    Truck t = new Truck();
-    t.setLicenseNumber("T1098");
-    t.setCapacity(20D);
-    Ebean.save(t);
-
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestDeleteFromPersistenceContext.java b/ebean-core/src/test/java/org/tests/transaction/TestDeleteFromPersistenceContext.java
deleted file mode 100644
index 93f1cbbfe..000000000
--- a/ebean-core/src/test/java/org/tests/transaction/TestDeleteFromPersistenceContext.java
+++ /dev/null
@@ -1,57 +0,0 @@
-package org.tests.transaction;
-
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebeaninternal.api.SpiTransaction;
-import org.tests.model.basic.EBasicVer;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
-
-import static junit.framework.TestCase.assertNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertSame;
-
-public class TestDeleteFromPersistenceContext extends BaseTestCase {
-
-  @Test
-  public void testDeleteBean() {
-
-    ResetBasicData.reset();
-
-    EBasicVer bean = new EBasicVer("Please Delete Me");
-    Ebean.save(bean);
-
-    SpiTransaction transaction = (SpiTransaction) Ebean.beginTransaction();
-    try {
-
-      EBasicVer bean2 = Ebean.find(EBasicVer.class, bean.getId());
-      assertNotSame(bean, bean2);
-
-      EBasicVer bean3 = Ebean.find(EBasicVer.class, bean.getId());
-      // same instance from PersistenceContext
-      assertSame(bean2, bean3);
-
-      Object bean4 = transaction.getPersistenceContext().get(EBasicVer.class, bean.getId());
-      assertSame(bean2, bean4);
-
-      Ebean.delete(bean2);
-
-      Object bean5 = transaction.getPersistenceContext().get(EBasicVer.class, bean.getId());
-      assertNull("Bean is deleted from PersistenceContext", bean5);
-
-      Ebean.commitTransaction();
-
-    } finally {
-      Ebean.endTransaction();
-    }
-
-    EBasicVer bean6 = Ebean.find(EBasicVer.class).where().eq("id", bean.getId()).findOne();
-    assertNull("Bean where id eq is not found " + bean6, bean6);
-
-    awaitL2Cache();
-    EBasicVer bean7 = Ebean.find(EBasicVer.class, bean.getId());
-    assertNull("Bean is not expected to be found? " + bean7, bean7);
-
-  }
-
-}
diff --git a/ebean-core/src/test/java/org/tests/unitinternal/TestBasics.java b/ebean-core/src/test/java/org/tests/unitinternal/TestBasics.java
deleted file mode 100644
index ae0c42370..000000000
--- a/ebean-core/src/test/java/org/tests/unitinternal/TestBasics.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package org.tests.unitinternal;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-
-public class TestBasics {
-
-
-  private String parentPath(String path) {
-
-    int pos = path.lastIndexOf('.');
-    if (pos == -1) {
-      return null;
-    } else {
-      return path.substring(0, pos);
-    }
-  }
-
-  @Test
-  public void testParentPath() {
-
-    Assert.assertTrue((parentPath("banana") == null));
-    Assert.assertTrue((parentPath("banana.apple").equals("banana")));
-    Assert.assertTrue((parentPath("banana.apple.o").equals("banana.apple")));
-
-  }
-}
diff --git a/ebean-core/src/test/java/org/tests/unitinternal/TestEqualsOnEnhanced.java b/ebean-core/src/test/java/org/tests/unitinternal/TestEqualsOnEnhanced.java
deleted file mode 100644
index b11b2626b..000000000
--- a/ebean-core/src/test/java/org/tests/unitinternal/TestEqualsOnEnhanced.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.tests.unitinternal;
-
-import io.ebean.BaseTestCase;
-import io.ebean.bean.EntityBean;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.junit.Assert;
-import org.junit.Test;
-
-public class TestEqualsOnEnhanced extends BaseTestCase {
-
-  @Test
-  public void test() {
-
-    Customer c = new Customer();
-    if (c instanceof EntityBean) {
-      Order o = new Order();
-      if (o instanceof EntityBean) {
-
-        c.setId(1);
-
-        o.setId(1);
-
-        Assert.assertFalse(c.equals(o));
-        Assert.assertFalse(c.equals(null));
-        Assert.assertTrue(c.equals(c));
-
-        Customer c2 = new Customer();
-        c2.setId(1);
-        Assert.assertTrue(c.equals(c2));
-
-        Customer c3 = new Customer();
-        // c2.setId(1);
-        Assert.assertFalse(c.equals(c3));
-
-        Customer c4 = new Customer();
-        c4.setId(2);
-        Assert.assertFalse(c.equals(c4));
-
-      }
-    }
-
-  }
-}
diff --git a/ebean-core/src/test/resources/META-INF/services/io.ebeaninternal.api.SpiLoggerFactory b/ebean-core/src/test/resources/META-INF/services/io.ebeaninternal.api.SpiLoggerFactory
deleted file mode 100644
index e4a925737..000000000
--- a/ebean-core/src/test/resources/META-INF/services/io.ebeaninternal.api.SpiLoggerFactory
+++ /dev/null
@@ -1 +0,0 @@
-io.ebeantest.CapturingLoggerFactory
diff --git a/ebean-core/src/test/resources/ebean.mf b/ebean-core/src/test/resources/ebean.mf
deleted file mode 100644
index fc2fd6902..000000000
--- a/ebean-core/src/test/resources/ebean.mf
+++ /dev/null
@@ -1,7 +0,0 @@
-agent-use-only: true
-profile-location: true
-entity-packages: org,misc
-transactional-packages: org
-querybean-packages: none
-synthetic: true
-
diff --git a/ebean-core/src/test/resources/logback-test.xml b/ebean-core/src/test/resources/logback-test.xml
deleted file mode 100644
index 1b8a60a9b..000000000
--- a/ebean-core/src/test/resources/logback-test.xml
+++ /dev/null
@@ -1,101 +0,0 @@
-<configuration scan="true" scanPeriod="10 seconds">
-  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-      <level>TRACE</level>
-    </filter>
-    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
-      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
-    </encoder>
-  </appender>
-
-  <appender name="APPLICATION" class="ch.qos.logback.core.rolling.RollingFileAppender">
-    <File>target/log/application.log</File>
-    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-      <level>TRACE</level>
-    </filter>
-    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-      <FileNamePattern>log/application.log.%d{yyyy-MM-dd}</FileNamePattern>
-      <MaxHistory>90</MaxHistory>
-    </rollingPolicy>
-    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
-      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
-    </encoder>
-  </appender>
-
-  <appender name="READAUDIT_QUERY_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
-    <File>target/log/readAuditQuery.log</File>
-    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-      <FileNamePattern>log/readAuditQuery.log.%d{yyyy-MM-dd}</FileNamePattern>
-      <MaxHistory>90</MaxHistory>
-    </rollingPolicy>
-    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
-      <pattern>%d{HH:mm:ss.SSS} %msg%n</pattern>
-    </encoder>
-  </appender>
-
-  <appender name="READAUDIT_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
-    <File>target/log/readAudit.log</File>
-    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-      <FileNamePattern>log/readAudit.log.%d{yyyy-MM-dd}</FileNamePattern>
-      <MaxHistory>90</MaxHistory>
-    </rollingPolicy>
-    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
-      <pattern>%d{HH:mm:ss.SSS} %msg%n</pattern>
-    </encoder>
-  </appender>
-
-  <appender name="CHANGE_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
-    <File>target/log/change-log.log</File>
-    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-      <FileNamePattern>log/changeLog.log.%d{yyyy-MM-dd}</FileNamePattern>
-      <MaxHistory>90</MaxHistory>
-    </rollingPolicy>
-    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
-      <pattern>%d{HH:mm:ss.SSS} %msg%n</pattern>
-    </encoder>
-  </appender>
-
-  <logger name="io.ebean.ReadAuditQuery" level="TRACE" additivity="false">
-    <appender-ref ref="READAUDIT_QUERY_LOG"/>
-  </logger>
-
-  <logger name="io.ebean.ReadAudit" level="TRACE" additivity="false">
-    <appender-ref ref="READAUDIT_LOG"/>
-  </logger>
-
-  <logger name="io.ebean.ChangeLog" level="TRACE" additivity="false">
-    <appender-ref ref="CHANGE_LOG"/>
-  </logger>
-
-  <root level="WARN">
-    <appender-ref ref="APPLICATION"/>
-    <appender-ref ref="STDOUT"/>
-  </root>
-
-
-  <logger name="org.tests" level="INFO"/>
-  <logger name="io.ebean" level="INFO"/>
-
-  <logger name="io.ebean.docker" level="TRACE"/>
-<!--  <logger name="io.ebean.DDL" level="DEBUG"/>-->
-
-<!--  <logger name="io.ebean.SQL" level="TRACE"/>-->
-<!--  <logger name="io.ebean.TXN" level="TRACE"/>-->
-<!--  <logger name="io.ebean.SUM" level="TRACE"/>-->
-
-<!--  <logger name="io.ebean.cache" level="TRACE"/>-->
-<!--  <logger name="io.ebean.cache.REGION" level="TRACE"/>-->
-<!--  <logger name="io.ebean.cache.TABLEMOD" level="TRACE"/>-->
-
-<!--  <logger name="io.ebean.cache.QUERY" level="TRACE"/>-->
-<!--  <logger name="io.ebean.cache.BEAN" level="TRACE"/>-->
-<!--  <logger name="io.ebean.cache.NATKEY" level="TRACE"/>-->
-<!--  <logger name="io.ebean.cache.COLL" level="TRACE"/>-->
-
-  <logger name="io.ebeaninternal.server.lib" level="TRACE"/>
-
-  <!--<logger name="io.ebeaninternal.server.autotune" level="TRACE"/>-->
-
-  <!--<logger name="io.ebean.ChangeLog" level="INFO"/>-->
-
-</configuration>
diff --git a/ebean-ddl-generator/pom.xml b/ebean-ddl-generator/pom.xml
index e454770b8..4fabbbe9b 100644
--- a/ebean-ddl-generator/pom.xml
+++ b/ebean-ddl-generator/pom.xml
@@ -4,19 +4,20 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <name>ebean ddl generation</name>
   <description>DDL and DB Migration generation</description>
   <artifactId>ebean-ddl-generator</artifactId>
+<!--  <version>12.11.4A</version>-->
 
   <dependencies>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-ddl-runner</artifactId>
-      <version>1.0</version>
+      <version>1.1</version>
     </dependency>
 
     <dependency>
@@ -28,14 +29,14 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core-type</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
 
@@ -49,9 +50,9 @@
 
     <!-- test dependencies -->
     <dependency>
-      <groupId>org.avaje.composite</groupId>
+      <groupId>io.avaje</groupId>
       <artifactId>junit</artifactId>
-      <version>1.1</version>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/DdlGenerator.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/DdlGenerator.java
index fe546ab27..69a4af033 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/DdlGenerator.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/DdlGenerator.java
@@ -58,13 +58,13 @@ public class DdlGenerator implements SpiDdlGenerator {
 
   public DdlGenerator(SpiEbeanServer server) {
     this.server = server;
-    final DatabaseConfig config = server.getServerConfig();
+    final DatabaseConfig config = server.config();
     this.jaxbPresent = Detect.isJAXBPresent(config);
     this.generateDdl = config.isDdlGenerate();
     this.extraDdl = config.isDdlExtra();
     this.createOnly = config.isDdlCreateOnly();
     this.dbSchema = config.getDbSchema();
-    final DatabasePlatform databasePlatform = server.getDatabasePlatform();
+    final DatabasePlatform databasePlatform = server.databasePlatform();
     this.platform = databasePlatform.getPlatform();
     this.platformName = platform.base().name();
     if (!config.getTenantMode().isDdlEnabled() && config.isDdlRun()) {
@@ -141,7 +141,7 @@ public class DdlGenerator implements SpiDdlGenerator {
 
   private Connection obtainConnection() {
     try {
-      return server.getDataSource().getConnection();
+      return server.dataSource().getConnection();
     } catch (SQLException e) {
       throw new PersistenceException("Failed to obtain connection to run DDL", e);
     }
@@ -150,7 +150,7 @@ public class DdlGenerator implements SpiDdlGenerator {
   private void createSchemaIfRequired(Connection connection) {
     try {
       for (String schema : dbSchema.split(",")) {
-        server.getDatabasePlatform().createSchemaIfNotExists(schema, connection);
+        server.databasePlatform().createSchemaIfNotExists(schema, connection);
       }
     } catch (SQLException e) {
       throw new PersistenceException("Failed to create DB Schema", e);
@@ -231,7 +231,7 @@ public class DdlGenerator implements SpiDdlGenerator {
    * extra-ddl.xml should have some partition initialisation but this helps people get going.
    */
   private void checkInitialTablePartitions(Connection connection) {
-    DatabasePlatform databasePlatform = server.getDatabasePlatform();
+    DatabasePlatform databasePlatform = server.databasePlatform();
     try {
       StringBuilder sb = new StringBuilder();
       for (MTable table : currentModel.getPartitionedTables()) {
@@ -255,11 +255,11 @@ public class DdlGenerator implements SpiDdlGenerator {
   }
 
   protected void runInitSql(Connection connection) throws IOException {
-    runResourceScript(connection, server.getServerConfig().getDdlInitSql());
+    runResourceScript(connection, server.config().getDdlInitSql());
   }
 
   protected void runSeedSql(Connection connection) throws IOException {
-    runResourceScript(connection, server.getServerConfig().getDdlSeedSql());
+    runResourceScript(connection, server.config().getDdlSeedSql());
   }
 
   protected void runResourceScript(Connection connection, String sqlScript) throws IOException {
@@ -321,11 +321,11 @@ public class DdlGenerator implements SpiDdlGenerator {
   }
 
   protected String getDropFileName() {
-    return server.getName() + "-drop-all.sql";
+    return server.name() + "-drop-all.sql";
   }
 
   protected String getCreateFileName() {
-    return server.getName() + "-create-all.sql";
+    return server.name() + "-create-all.sql";
   }
 
   protected CurrentModel currentModel() {
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/DefaultDbMigration.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/DefaultDbMigration.java
index 5bb40fa08..a7a3703d7 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/DefaultDbMigration.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/DefaultDbMigration.java
@@ -128,7 +128,7 @@ public class DefaultDbMigration implements DbMigration {
   @Override
   public void setServer(Database database) {
     this.server = (SpiEbeanServer) database;
-    setServerConfig(server.getServerConfig());
+    setServerConfig(server.config());
   }
 
   @Override
@@ -677,7 +677,7 @@ public class DefaultDbMigration implements DbMigration {
     }
     if (vanillaPlatform || databasePlatform == null) {
       // not explicitly set so use the platform of the server
-      databasePlatform = server.getDatabasePlatform();
+      databasePlatform = server.databasePlatform();
     }
     if (databaseConfig != null) {
       if (strictMode != null) {
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PostgresDdl.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PostgresDdl.java
index 807bec456..734621a66 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PostgresDdl.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PostgresDdl.java
@@ -24,6 +24,7 @@ public class PostgresDdl extends PlatformDdl {
     this.indexConcurrent = "concurrently ";
   }
 
+  @Override
   public String setLockTimeout(int lockTimeoutSeconds) {
     return "set lock_timeout = " + (lockTimeoutSeconds * 1000);
   }
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/CurrentModel.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/CurrentModel.java
index 0ff9a9bc4..e5c8743d2 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/CurrentModel.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/CurrentModel.java
@@ -42,7 +42,7 @@ public class CurrentModel {
    * Construct with a given EbeanServer instance for DDL create all generation, not migration.
    */
   public CurrentModel(SpiEbeanServer server) {
-    this(server, server.getServerConfig().getConstraintNaming(), true);
+    this(server, server.config().getConstraintNaming(), true);
   }
 
   /**
@@ -58,11 +58,11 @@ public class CurrentModel {
 
   private CurrentModel(SpiEbeanServer server, DbConstraintNaming constraintNaming, boolean platformTypes) {
     this.server = server;
-    this.databasePlatform = server.getDatabasePlatform();
+    this.databasePlatform = server.databasePlatform();
     this.constraintNaming = constraintNaming;
     this.platformTypes = platformTypes;
-    this.ddlHeader = server.getServerConfig().getDdlHeader();
-    this.jaxbPresent = Detect.isJAXBPresent(server.getServerConfig());
+    this.ddlHeader = server.config().getDdlHeader();
+    this.jaxbPresent = Detect.isJAXBPresent(server.config());
   }
 
   public DdlOptions getDdlOptions() {
@@ -139,7 +139,7 @@ public class CurrentModel {
     if (extraDdl != null) {
       List<DdlScript> ddlScript = extraDdl.getDdlScript();
       for (DdlScript script : ddlScript) {
-        if (script.isInit() && matchPlatform(server.getDatabasePlatform().getPlatform(), script.getPlatforms())) {
+        if (script.isInit() && matchPlatform(server.platform(), script.getPlatforms())) {
           ddl.append(prefix).append(script.getName()).append('\n');
           ddl.append(script.getValue());
         }
@@ -181,7 +181,7 @@ public class CurrentModel {
    * Return the platform specific DdlHandler (to generate DDL).
    */
   private DdlHandler handler() {
-    return PlatformDdlBuilder.create(databasePlatform).createDdlHandler(server.getServerConfig());
+    return PlatformDdlBuilder.create(databasePlatform).createDdlHandler(server.config());
   }
 
   /**
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/MTable.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/MTable.java
index 71faa1c44..5bc946fa7 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/MTable.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/MTable.java
@@ -89,16 +89,16 @@ public class MTable {
   private final List<String> droppedColumns = new ArrayList<>();
 
   public MTable(BeanDescriptor<?> descriptor) {
-    this.name = descriptor.getBaseTable();
-    this.identityMode = descriptor.getIdentityMode();
-    this.storageEngine = descriptor.getStorageEngine();
-    this.partitionMeta = descriptor.getPartitionMeta();
-    this.comment = descriptor.getDbComment();
+    this.name = descriptor.baseTable();
+    this.identityMode = descriptor.identityMode();
+    this.storageEngine = descriptor.storageEngine();
+    this.partitionMeta = descriptor.partitionMeta();
+    this.comment = descriptor.dbComment();
     if (descriptor.isHistorySupport()) {
       withHistory = true;
-      BeanProperty whenCreated = descriptor.getWhenCreatedProperty();
+      BeanProperty whenCreated = descriptor.whenCreatedProperty();
       if (whenCreated != null) {
-        whenCreatedColumn = whenCreated.getDbColumn();
+        whenCreatedColumn = whenCreated.dbColumn();
       }
     }
   }
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildBeanVisitor.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildBeanVisitor.java
index 4bbc055e2..704fcf0af 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildBeanVisitor.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildBeanVisitor.java
@@ -36,7 +36,7 @@ public class ModelBuildBeanVisitor implements BeanVisitor {
     // add the table to the model
     ctx.addTable(table);
 
-    InheritInfo inheritInfo = descriptor.getInheritInfo();
+    InheritInfo inheritInfo = descriptor.inheritInfo();
     if (inheritInfo != null && inheritInfo.isRoot()) {
       // add the discriminator column
       String discColumn = inheritInfo.getDiscriminatorColumn();
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildContext.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildContext.java
index 2dc0b245d..939592942 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildContext.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildContext.java
@@ -145,7 +145,7 @@ public class ModelBuildContext {
   public String getColumnDefn(BeanProperty p, boolean strict) {
     DbPlatformType dbType = getDbType(p);
     if (dbType == null) {
-      throw new IllegalStateException("Unknown DbType mapping for " + p.getFullBeanName());
+      throw new IllegalStateException("Unknown DbType mapping for " + p.fullName());
     }
     return p.renderDbType(dbType, strict);
   }
@@ -153,19 +153,19 @@ public class ModelBuildContext {
   private DbPlatformType getDbType(BeanProperty p) {
 
     if (p.isDbEncrypted()) {
-      return dbTypeMap.get(p.getDbEncryptedType());
+      return dbTypeMap.get(p.dbEncryptedType());
     }
     if (p.isLocalEncrypted()) {
       // scalar type potentially wrapping varbinary db type
-      ScalarType<Object> scalarType = p.getScalarType();
+      ScalarType<Object> scalarType = p.scalarType();
       int jdbcType = scalarType.getJdbcType();
       return dbTypeMap.get(jdbcType);
     }
 
     // can be the logical JSON types (JSON, JSONB, JSONClob, JSONBlob, JSONVarchar)
-    int dbType = p.getDbType(platformTypes);
+    int dbType = p.dbType(platformTypes);
     if (dbType == 0) {
-      throw new RuntimeException("No scalarType defined for " + p.getFullBeanName());
+      throw new RuntimeException("No scalarType defined for " + p.fullName());
     }
     return dbTypeMap.get(dbType);
   }
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildElementTable.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildElementTable.java
index 157145d7d..a8a4d944e 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildElementTable.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildElementTable.java
@@ -16,8 +16,8 @@ public class ModelBuildElementTable {
    */
   public static void build(ModelBuildContext ctx, BeanPropertyAssocMany<?> manyProp) {
 
-    BeanTable beanTable = manyProp.getBeanTable();
-    BeanDescriptor<?> targetDescriptor = manyProp.getTargetDescriptor();
+    BeanTable beanTable = manyProp.beanTable();
+    BeanDescriptor<?> targetDescriptor = manyProp.targetDescriptor();
     MTable table = new MTable(beanTable.getBaseTable());
 
     VisitProperties.visit(targetDescriptor, new ModelBuildPropertyVisitor(ctx, table, targetDescriptor));
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildIntersectionTable.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildIntersectionTable.java
index e117c3ead..179de2ef8 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildIntersectionTable.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildIntersectionTable.java
@@ -5,7 +5,6 @@ import io.ebeaninternal.dbmigration.model.MTable;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanProperty;
 import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
-import io.ebeaninternal.server.deploy.PropertyForeignKey;
 import io.ebeaninternal.server.deploy.TableJoin;
 import io.ebeaninternal.server.deploy.TableJoinColumn;
 
@@ -25,8 +24,8 @@ class ModelBuildIntersectionTable {
   ModelBuildIntersectionTable(ModelBuildContext ctx, BeanPropertyAssocMany<?> manyProp) {
     this.ctx = ctx;
     this.manyProp = manyProp;
-    this.intersectionTableJoin = manyProp.getIntersectionTableJoin();
-    this.tableJoin = manyProp.getTableJoin();
+    this.intersectionTableJoin = manyProp.intersectionTableJoin();
+    this.tableJoin = manyProp.tableJoin();
   }
 
   public MTable build() {
@@ -34,13 +33,13 @@ class ModelBuildIntersectionTable {
     intersectionTable = createTable();
     MTable existingTable = ctx.addTable(intersectionTable);
     if (existingTable != null) {
-      throw new IllegalStateException("Property " + manyProp.getFullBeanName() + " has duplicate ManyToMany intersection table " + intersectionTable.getName()
+      throw new IllegalStateException("Property " + manyProp.fullName() + " has duplicate ManyToMany intersection table " + intersectionTable.getName()
         + ". Please use @JoinTable to define unique table to use");
     }
 
     buildFkConstraints();
 
-    if (manyProp.getTargetDescriptor().isDraftable()) {
+    if (manyProp.targetDescriptor().isDraftable()) {
       ctx.createDraft(intersectionTable, false);
     }
 
@@ -51,16 +50,16 @@ class ModelBuildIntersectionTable {
 
     if (manyProp.hasForeignKeyConstraint()) {
       ctx.fkeyBuilder(intersectionTable)
-        .addForeignKey(manyProp.getBeanDescriptor(), intersectionTableJoin, true)
-        .addForeignKey(manyProp.getTargetDescriptor(), tableJoin, false);
+        .addForeignKey(manyProp.descriptor(), intersectionTableJoin, true)
+        .addForeignKey(manyProp.targetDescriptor(), tableJoin, false);
     }
     intersectionTable.checkDuplicateForeignKeys();
   }
 
   private MTable createTable() {
 
-    BeanDescriptor<?> localDesc = manyProp.getBeanDescriptor();
-    BeanDescriptor<?> targetDesc = manyProp.getTargetDescriptor();
+    BeanDescriptor<?> localDesc = manyProp.descriptor();
+    BeanDescriptor<?> targetDesc = manyProp.targetDescriptor();
 
     String tableName = intersectionTableJoin.getTable();
     MTable table = new MTable(tableName);
@@ -86,7 +85,7 @@ class ModelBuildIntersectionTable {
 
   private void addColumn(MTable table, BeanDescriptor<?> desc, String column, String findPropColumn) {
 
-    BeanProperty p = desc.getIdBinder().findBeanProperty(findPropColumn);
+    BeanProperty p = desc.idBinder().findBeanProperty(findPropColumn);
     if (p == null) {
       throw new RuntimeException("Could not find id property for " + findPropColumn);
     }
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildPropertyVisitor.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildPropertyVisitor.java
index 73928a5d0..bb188442e 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildPropertyVisitor.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildPropertyVisitor.java
@@ -50,7 +50,7 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
     this.ctx = ctx;
     this.table = table;
     this.beanDescriptor = beanDescriptor;
-    addIndexes(beanDescriptor.getIndexDefinitions());
+    addIndexes(beanDescriptor.indexDefinitions());
   }
 
   /**
@@ -187,21 +187,21 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
   @Override
   public void visitOneImported(BeanPropertyAssocOne<?> p) {
 
-    TableJoinColumn[] columns = p.getTableJoin().columns();
+    TableJoinColumn[] columns = p.tableJoin().columns();
     if (columns.length == 0) {
-      throw new RuntimeException("No join columns for " + p.getFullBeanName());
+      throw new RuntimeException("No join columns for " + p.fullName());
     }
 
-    ImportedId importedId = p.getImportedId();
+    ImportedId importedId = p.importedId();
 
     List<MColumn> modelColumns = new ArrayList<>(columns.length);
 
     MCompoundForeignKey compoundKey = null;
     if (columns.length > 1) {
       // compound foreign key
-      String refTable = p.getTargetDescriptor().getBaseTable();
-      String fkName = foreignKeyConstraintName(p.getName());
-      String fkIndex = foreignKeyIndexName(p.getName());
+      String refTable = p.targetDescriptor().baseTable();
+      String fkName = foreignKeyConstraintName(p.name());
+      String fkIndex = foreignKeyIndexName(p.name());
       compoundKey = new MCompoundForeignKey(fkName, refTable, fkIndex);
       table.addForeignKey(compoundKey);
     }
@@ -214,25 +214,25 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
         throw new RuntimeException("Imported BeanProperty not found?");
       }
       String columnDefn = ctx.getColumnDefn(importedProperty, true);
-      String refColumn = importedProperty.getDbColumn();
+      String refColumn = importedProperty.dbColumn();
 
       MColumn col = table.addColumn(dbCol, columnDefn, !p.isNullable());
-      col.setDbMigrationInfos(p.getDbMigrationInfos());
-      col.setDefaultValue(p.getDbColumnDefault());
+      col.setDbMigrationInfos(p.dbMigrationInfos());
+      col.setDefaultValue(p.dbColumnDefault());
       if (columns.length == 1) {
-        if (p.hasForeignKeyConstraint() && !importedProperty.getBeanDescriptor().suppressForeignKey()) {
+        if (p.hasForeignKeyConstraint() && !importedProperty.descriptor().suppressForeignKey()) {
           // single references column (put it on the column)
-          String refTable = importedProperty.getBeanDescriptor().getBaseTable();
+          String refTable = importedProperty.descriptor().getBaseTable();
           if (refTable == null) {
             // odd case where an EmbeddedId only has 1 property
-            refTable = p.getTargetDescriptor().getBaseTable();
+            refTable = p.targetDescriptor().getBaseTable();
           }
           col.setReferences(refTable + "." + refColumn);
           col.setForeignKeyName(foreignKeyConstraintName(col.getName()));
           if (p.hasForeignKeyIndex()) {
             col.setForeignKeyIndex(foreignKeyIndexName(col.getName()));
           }
-          PropertyForeignKey foreignKey = p.getForeignKey();
+          PropertyForeignKey foreignKey = p.foreignKey();
           if (foreignKey != null) {
             col.setForeignKeyModes(foreignKey.getOnDelete(), foreignKey.getOnUpdate());
           }
@@ -253,7 +253,7 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
 
       } else {
         String[] cols = indexSetAdd(toColumnNames(modelColumns));
-        String uqName = uniqueConstraintName(p.getName());
+        String uqName = uniqueConstraintName(p.name());
         table.addUniqueConstraint(new MCompoundUniqueConstraint(cols, uqName));
       }
     }
@@ -268,17 +268,17 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
 
     // using non-strict mode to render the DB type such that we have a
     // "logical" type like jsonb(200) that can map to JSONB or VARCHAR(200)
-    MColumn col = new MColumn(p.getDbColumn(), ctx.getColumnDefn(p, false));
-    col.setComment(p.getDbComment());
+    MColumn col = new MColumn(p.dbColumn(), ctx.getColumnDefn(p, false));
+    col.setComment(p.dbComment());
     col.setDraftOnly(p.isDraftOnly());
     col.setHistoryExclude(p.isExcludedFromHistory());
 
     if (p.isId() || p.isImportedPrimaryKey()) {
       col.setPrimaryKey(true);
-      if (p.getBeanDescriptor().isUseIdGenerator()) {
+      if (p.descriptor().isUseIdGenerator()) {
         col.setIdentity(true);
       }
-      TableJoin primaryKeyJoin = p.getBeanDescriptor().getPrimaryKeyJoin();
+      TableJoin primaryKeyJoin = p.descriptor().primaryKeyJoin();
       if (primaryKeyJoin != null && !table.isPartitioned()) {
         final PropertyForeignKey foreignKey = primaryKeyJoin.getForeignKey();
         if (foreignKey == null || !foreignKey.isNoConstraint()) {
@@ -291,25 +291,25 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
         }
       }
     } else {
-      col.setDefaultValue(p.getDbColumnDefault());
+      col.setDefaultValue(p.dbColumnDefault());
       if (allowNonNull && (!p.isNullable() || p.isDDLNotNull())) {
         col.setNotnull(true);
       }
     }
 
-    col.setDbMigrationInfos(p.getDbMigrationInfos());
+    col.setDbMigrationInfos(p.dbMigrationInfos());
 
     if (p.isUnique() && !p.isId()) {
       col.setUnique(uniqueConstraintName(col.getName()));
       indexSetAdd(col.getName());
     }
-    Set<String> checkConstraintValues = p.getDbCheckConstraintValues();
+    Set<String> checkConstraintValues = p.dbCheckConstraintValues();
     if (checkConstraintValues != null) {
       if (beanDescriptor.hasInheritance()) {
-        InheritInfo inheritInfo = beanDescriptor.getInheritInfo();
-        inheritInfo.appendCheckConstraintValues(p.getName(), checkConstraintValues);
+        InheritInfo inheritInfo = beanDescriptor.inheritInfo();
+        inheritInfo.appendCheckConstraintValues(p.name(), checkConstraintValues);
       }
-      col.setCheckConstraint(buildCheckConstraint(p.getDbColumn(), checkConstraintValues));
+      col.setCheckConstraint(buildCheckConstraint(p.dbColumn(), checkConstraintValues));
       col.setCheckConstraintName(checkConstraintName(col.getName()));
     }
 
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/visitor/VisitAllUsing.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/visitor/VisitAllUsing.java
index 0cb6db92d..bfaed1ffe 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/visitor/VisitAllUsing.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/model/visitor/VisitAllUsing.java
@@ -21,7 +21,7 @@ public final class VisitAllUsing extends VisitProperties {
    * Visit all the descriptors for a given server.
    */
   public VisitAllUsing(BeanVisitor visitor, SpiEbeanServer server) {
-    this(visitor, server.getBeanDescriptors());
+    this(visitor, server.descriptors());
   }
 
   /**
diff --git a/ebean-ddl-generator/src/test/java/io/ebean/BaseTestCase.java b/ebean-ddl-generator/src/test/java/io/ebean/BaseTestCase.java
index 4c0410ff3..223598f91 100644
--- a/ebean-ddl-generator/src/test/java/io/ebean/BaseTestCase.java
+++ b/ebean-ddl-generator/src/test/java/io/ebean/BaseTestCase.java
@@ -12,12 +12,8 @@ import io.ebeaninternal.api.SpiTransaction;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.expression.platform.DbExpressionHandler;
 import io.ebeaninternal.server.expression.platform.DbExpressionHandlerFactory;
-import io.ebeaninternal.server.transaction.TransactionScopeManager;
 import org.assertj.core.api.AbstractCharSequenceAssert;
-import org.junit.After;
-import org.junit.Rule;
-import org.junit.rules.TestName;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -26,27 +22,12 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
 
-@RunWith(ConditionalTestRunner.class)
+@ExtendWith(PlatformCondition.class)
 public abstract class BaseTestCase {
 
   protected static Logger logger = LoggerFactory.getLogger(BaseTestCase.class);
 
-  @Rule public TestName name = new TestName();
-
-  @After
-  public void checkForLeak() {
-    TransactionScopeManager scope = spiEbeanServer().getTransactionManager().scope();
-    SpiTransaction trans = scope.getInScope();
-    if (trans != null) {
-      String msg = getClass().getSimpleName() + "." + name.getMethodName() + " did not clear threadScope:" + trans;
-      scope.clearExternal(); // clear for next test
-      fail(msg);
-    }
-  }
-
-
   /**
    * this is the clock delta that may occur between testing machine and db server.
    * If the clock delta of DB server is in future, an "asOf" query may not find the
@@ -73,99 +54,6 @@ public abstract class BaseTestCase {
     }
   }
 
-  protected void clearAllL2Cache() {
-    server().getServerCacheManager().clearAll();
-  }
-
-  protected void resetAllMetrics() {
-    server().getMetaInfoManager().resetAllMetrics();
-  }
-
-  protected ServerMetrics collectMetrics() {
-     return server().getMetaInfoManager().collectMetrics();
-  }
-
-  protected List<MetaTimedMetric> visitTimedMetrics() {
-    return collectMetrics().timedMetrics();
-  }
-
-  protected List<MetaTimedMetric> sqlMetrics() {
-    List<MetaTimedMetric> timedMetrics = visitTimedMetrics();
-
-    return timedMetrics.stream()
-      .filter((it) -> it.name().startsWith("sql.") || it.name().startsWith("orm."))
-      .collect(Collectors.toList());
-  }
-
-  protected SpiTransaction getInScopeTransaction() {
-    return spiEbeanServer().getTransactionManager().scope().getInScope();
-  }
-
-  /**
-   * Return the generated sql trimming column alias if required.
-   */
-  protected String sqlOf(Query<?> query) {
-    return trimSql(query.getGeneratedSql());
-  }
-
-  /**
-   * Return the generated sql trimming column alias if required.
-   */
-  protected String sqlOf(Query<?> query, int columns) {
-    return trimSql(query.getGeneratedSql(), columns);
-  }
-
-  protected void assertSqlBind(String sql) {
-    assertThat(sql).contains("-- bind");
-  }
-
-  protected void assertSqlBind(List<String> sql, int i) {
-    assertThat(sql.get(i)).contains("-- bind");
-  }
-
-  protected void assertSqlBind(List<String> sql, int from, int to) {
-    for (int i = from; i <= to; i++) {
-      assertThat(sql.get(i)).contains("-- bind");
-    }
-  }
-
-  protected AbstractCharSequenceAssert<?, String> assertSql(Query<?> query, int count) {
-    return org.assertj.core.api.Assertions.assertThat(sqlOf(query, count));
-  }
-
-  protected AbstractCharSequenceAssert<?, String> assertSql(Query<?> query) {
-    return org.assertj.core.api.Assertions.assertThat(sqlOf(query));
-  }
-
-  protected AbstractCharSequenceAssert<?, String> assertSql(String sql) {
-    return org.assertj.core.api.Assertions.assertThat(trimSql(sql));
-  }
-
-  protected String trimSql(String sql) {
-    if (sql.contains(" c0,") || sql.contains(" c0 ") || sql.contains(" c1,") || sql.contains(" c1 ")) {
-      // for oracle we include column alias so lets remove those
-      return trimSql(sql, 10);
-    }
-    return sql;//trimSql(sql, 0);
-  }
-
-  /**
-   * Trim out column alias if required from the generated sql.
-   */
-  protected String trimSql(String sql, int columns) {
-    for (int i = 0; i <= columns; i++) {
-      sql = StringHelper.replace(sql, " c" + i + ",", ",");
-    }
-    for (int i = 0; i <= columns; i++) {
-      sql = StringHelper.replace(sql, " c" + i + " ", " ");
-    }
-    return sql;
-  }
-
-  public boolean isPlatformCaseSensitive() {
-    return spiEbeanServer().getDatabasePlatform().isCaseSensitiveCollation();
-  }
-
   /**
    * MS SQL Server does not allow setting explicit values on identity columns
    * so tests that do this need to be skipped for SQL Server.
@@ -178,22 +66,10 @@ public abstract class BaseTestCase {
     return Platform.H2 == platform();
   }
 
-  public boolean isHSqlDb() {
-    return Platform.HSQLDB == platform();
-  }
-
   public boolean isOracle() {
     return Platform.ORACLE == platform();
   }
 
-  public boolean isNuoDb() {
-    return Platform.NUODB == platform();
-  }
-
-  public boolean isDb2() {
-    return Platform.DB2 == platform();
-  }
-
   public boolean isPostgres() {
     return Platform.POSTGRES == platform().base();
   }
@@ -211,7 +87,7 @@ public abstract class BaseTestCase {
   }
 
   public boolean isPlatformBooleanNative() {
-    return Types.BOOLEAN == spiEbeanServer().getDatabasePlatform().getBooleanDbType();
+    return Types.BOOLEAN == spiEbeanServer().databasePlatform().getBooleanDbType();
   }
 
   public boolean isPlatformOrderNullsSupport() {
@@ -219,11 +95,11 @@ public abstract class BaseTestCase {
   }
 
   public boolean isPlatformSupportsDeleteTableAlias() {
-    return spiEbeanServer().getDatabasePlatform().isSupportsDeleteTableAlias();
+    return spiEbeanServer().databasePlatform().isSupportsDeleteTableAlias();
   }
 
   public boolean isPersistBatchOnCascade() {
-    return spiEbeanServer().getDatabasePlatform().getPersistBatchOnCascade() != PersistBatch.NONE;
+    return spiEbeanServer().databasePlatform().getPersistBatchOnCascade() != PersistBatch.NONE;
   }
 
   /**
@@ -233,63 +109,16 @@ public abstract class BaseTestCase {
     // do nothing, used to thread sleep
   }
 
-  protected <T> BeanDescriptor<T> getBeanDescriptor(Class<T> cls) {
-    return spiEbeanServer().getBeanDescriptor(cls);
-  }
-
-  protected <T> ServerCacheStatistics getBeanCacheStats(Class<T> cls, boolean reset) {
-    return server().getServerCacheManager().getBeanCache(cls).getStatistics(reset);
-  }
-
   protected Platform platform() {
-    return spiEbeanServer().getDatabasePlatform().getPlatform().base();
-  }
-
-  protected IdType idType() {
-    return spiEbeanServer().getDatabasePlatform().getDbIdentity().getIdType();
+    return spiEbeanServer().databasePlatform().getPlatform().base();
   }
 
   protected SpiEbeanServer spiEbeanServer() {
     return (SpiEbeanServer) DB.getDefault();
   }
 
-  protected EbeanServer server() {
-    return Ebean.getDefaultServer();
-  }
-
-  /**
-   * Platform specific IN clause assert.
-   */
-  protected void platformAssertIn(String sql, String containsIn) {
-    if (isPostgres()) {
-      assertThat(sql).contains(containsIn+" = any(");
-    } else {
-      assertThat(sql).contains(containsIn+" in ");
-    }
-    // H2 contains("where t0.name in (select * from table(x varchar = ?)");
-  }
-
-  /**
-   * Platform specific NOT IN clause assert.
-   */
-  protected void platformAssertNotIn(String sql, String containsIn) {
-    if (isPostgres()) {
-      assertThat(sql).contains(containsIn+" != all(");
-    } else {
-      assertThat(sql).contains(containsIn+" not in ");
-    }
-  }
-
-  /**
-   * Platform specific CONCAT clause.
-   */
-  protected String concat(String property0, String separator, String property1) {
-    return concat(property0, separator, property1, null);
-  }
-
-  protected String concat(String property0, String separator, String property1, String suffix) {
-    DbExpressionHandler dbExpressionHandler = DbExpressionHandlerFactory.from(spiEbeanServer().getDatabasePlatform());
-    return dbExpressionHandler.concat(property0, separator, property1, suffix);
+  protected Database server() {
+    return DB.getDefault();
   }
 
 }
diff --git a/ebean-ddl-generator/src/test/java/io/ebean/ConditionalTestRunner.java b/ebean-ddl-generator/src/test/java/io/ebean/ConditionalTestRunner.java
deleted file mode 100644
index 4adf007d8..000000000
--- a/ebean-ddl-generator/src/test/java/io/ebean/ConditionalTestRunner.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package io.ebean;
-
-import io.ebean.annotation.ForPlatform;
-import io.ebean.annotation.IgnorePlatform;
-import io.ebean.annotation.Platform;
-import org.junit.runner.notification.RunNotifier;
-import org.junit.runners.BlockJUnit4ClassRunner;
-import org.junit.runners.model.FrameworkMethod;
-import org.junit.runners.model.InitializationError;
-
-/**
- * This testrunner checks for an {@link IgnorePlatform} annotation and ignores the test.
- *
- * @author Roland Praml, FOCONIS AG
- */
-public class ConditionalTestRunner extends BlockJUnit4ClassRunner {
-  public ConditionalTestRunner(Class<?> klass) throws InitializationError {
-    super(klass);
-  }
-  @Override
-  public void runChild(FrameworkMethod method, RunNotifier notifier) {
-    ForPlatform forPlatform = method.getAnnotation(ForPlatform.class);
-    if (forPlatform != null) {
-      if (!platformMath(forPlatform.value())) {
-        notifier.fireTestIgnored(describeChild(method));
-        return;
-      }
-    }
-
-    IgnorePlatform ignore = method.getAnnotation(IgnorePlatform.class);
-
-    if (ignore == null || !platformMath(ignore.value())) {
-      super.runChild(method, notifier);
-    } else {
-      notifier.fireTestIgnored(describeChild(method));
-    }
-
-  }
-  private boolean platformMath(Platform[] platforms) {
-    Platform basePlatform = DB.getDefault().getPlatform().base();
-    for (Platform platform : platforms) {
-      if (platform.equals(basePlatform)) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
diff --git a/ebean-ddl-generator/src/test/java/io/ebean/PlatformCondition.java b/ebean-ddl-generator/src/test/java/io/ebean/PlatformCondition.java
new file mode 100644
index 000000000..b04f3db1c
--- /dev/null
+++ b/ebean-ddl-generator/src/test/java/io/ebean/PlatformCondition.java
@@ -0,0 +1,37 @@
+package io.ebean;
+
+import io.ebean.annotation.ForPlatform;
+import io.ebean.annotation.Platform;
+import org.junit.jupiter.api.extension.ConditionEvaluationResult;
+import org.junit.jupiter.api.extension.ExecutionCondition;
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+import java.lang.reflect.AnnotatedElement;
+import java.util.Optional;
+
+public class PlatformCondition implements ExecutionCondition {
+
+  private static final ConditionEvaluationResult ENABLED = ConditionEvaluationResult.enabled("ForPlatform is not present");
+
+  @Override
+  public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
+    Optional<AnnotatedElement> element = context.getElement();
+    if (element.isPresent()) {
+      final ForPlatform annotation = element.get().getAnnotation(ForPlatform.class);
+      if (annotation != null && !platformMath(annotation.value())) {
+        return ConditionEvaluationResult.disabled("@ForPlatform");
+      }
+    }
+    return ENABLED;
+  }
+
+  private boolean platformMath(Platform[] platforms) {
+    Platform basePlatform = DB.getDefault().platform().base();
+    for (Platform platform : platforms) {
+      if (platform.equals(basePlatform)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
diff --git a/ebean-ddl-generator/src/test/java/io/ebean/dbmigration/DbMigrationSqlServerTest.java b/ebean-ddl-generator/src/test/java/io/ebean/dbmigration/DbMigrationSqlServerTest.java
index 2ee20516c..b30bcbc8b 100644
--- a/ebean-ddl-generator/src/test/java/io/ebean/dbmigration/DbMigrationSqlServerTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebean/dbmigration/DbMigrationSqlServerTest.java
@@ -2,16 +2,19 @@ package io.ebean.dbmigration;
 
 import io.ebean.annotation.Platform;
 import io.ebeaninternal.api.DbOffline;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class DbMigrationSqlServerTest {
 
-  @Test(expected = IllegalArgumentException.class)
+  @Test
   public void need_explicitPlatform() {
-
     try {
       DbMigration dbMigration = DbMigration.create();
-      dbMigration.setPlatform(Platform.SQLSERVER);
+      assertThrows(IllegalArgumentException.class,
+        () -> dbMigration.setPlatform(Platform.SQLSERVER));
     } finally {
       DbOffline.reset();
     }
@@ -19,7 +22,6 @@ public class DbMigrationSqlServerTest {
 
   @Test
   public void explicit_16_isGood() {
-
     DbMigration dbMigration = DbMigration.create();
     dbMigration.setPlatform(Platform.SQLSERVER16);
     DbOffline.reset();
@@ -27,7 +29,6 @@ public class DbMigrationSqlServerTest {
 
   @Test
   public void explicit_17_isGood() {
-
     DbMigration dbMigration = DbMigration.create();
     dbMigration.setPlatform(Platform.SQLSERVER17);
     DbOffline.reset();
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationDropHistoryTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationDropHistoryTest.java
index 320406a7c..56752e7f2 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationDropHistoryTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationDropHistoryTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.dbmigration;
 import io.ebean.Database;
 import io.ebean.DatabaseFactory;
 import io.ebean.config.DatabaseConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationGenerateTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationGenerateTest.java
index f5bf01a56..cdfc3df13 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationGenerateTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationGenerateTest.java
@@ -4,7 +4,7 @@ import io.ebean.Database;
 import io.ebean.DatabaseFactory;
 import io.ebean.annotation.Platform;
 import io.ebean.config.DatabaseConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationTest.java
index 110fcb943..6eacdc2ac 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DbMigrationTest.java
@@ -6,7 +6,7 @@ import io.ebean.SqlUpdate;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
 import io.ebeaninternal.dbmigration.ddlgeneration.Helper;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.util.List;
@@ -16,7 +16,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 public class DbMigrationTest extends BaseTestCase {
 
   private void runScript(boolean expectErrors, String scriptName) throws IOException {
-    String ddl = Helper.asText(this, "/dbmigration/migrationtest/" + server().getPlatform().name().toLowerCase() + "/" + scriptName);
+    String ddl = Helper.asText(this, "/dbmigration/migrationtest/" + server().platform().name().toLowerCase() + "/" + scriptName);
     runScript(expectErrors, ddl, scriptName);
   }
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DefaultDbMigrationTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DefaultDbMigrationTest.java
index 642b3dc2c..dc787935f 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DefaultDbMigrationTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/DefaultDbMigrationTest.java
@@ -1,8 +1,8 @@
 package io.ebeaninternal.dbmigration;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DefaultDbMigrationTest {
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/H2PlatformTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/H2PlatformTest.java
index 8f68a49d9..f282b75fc 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/H2PlatformTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/H2PlatformTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.dbmigration;
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
 import io.ebeaninternal.dbmigration.ddlgeneration.platform.PlatformDdl;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/HanaPlatformTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/HanaPlatformTest.java
index bd0dea4c5..5bafff7e0 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/HanaPlatformTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/HanaPlatformTest.java
@@ -5,7 +5,7 @@ import io.ebean.config.dbplatform.DbPlatformType;
 import io.ebean.config.dbplatform.hana.HanaPlatform;
 import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
 import io.ebeaninternal.dbmigration.ddlgeneration.platform.PlatformDdl;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/IndexMigrationTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/IndexMigrationTest.java
index a22a42ec7..f953088b9 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/IndexMigrationTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/IndexMigrationTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.dbmigration;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.File;
 import java.io.IOException;
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/LastMigrationTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/LastMigrationTest.java
index e0adf54b2..3571b21cc 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/LastMigrationTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/LastMigrationTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.dbmigration;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.File;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/MChecksumTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/MChecksumTest.java
index e52c43755..0f41e7ba0 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/MChecksumTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/MChecksumTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.dbmigration;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.File;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/MySqlPlatformTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/MySqlPlatformTest.java
index 69486c4c7..8cfcae78a 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/MySqlPlatformTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/MySqlPlatformTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.dbmigration;
 import io.ebean.config.dbplatform.mysql.MySqlPlatform;
 import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
 import io.ebeaninternal.dbmigration.ddlgeneration.platform.PlatformDdl;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/OraclePlatformTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/OraclePlatformTest.java
index ff7472eb5..9f38f6879 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/OraclePlatformTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/OraclePlatformTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.dbmigration;
 import io.ebean.config.dbplatform.oracle.OraclePlatform;
 import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
 import io.ebeaninternal.dbmigration.ddlgeneration.platform.PlatformDdl;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/PostgresPlatformTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/PostgresPlatformTest.java
index c18e224cf..a374afbeb 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/PostgresPlatformTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/PostgresPlatformTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.dbmigration;
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
 import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
 import io.ebeaninternal.dbmigration.ddlgeneration.platform.PlatformDdl;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/SqlserverPlatformTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/SqlserverPlatformTest.java
index 0230b3534..9d80285a2 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/SqlserverPlatformTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/SqlserverPlatformTest.java
@@ -5,7 +5,7 @@ import io.ebean.config.dbplatform.DbPlatformType;
 import io.ebean.config.dbplatform.sqlserver.SqlServer17Platform;
 import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
 import io.ebeaninternal.dbmigration.ddlgeneration.platform.PlatformDdl;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/BaseDdlHandlerTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/BaseDdlHandlerTest.java
index f9742350e..6065448bc 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/BaseDdlHandlerTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/BaseDdlHandlerTest.java
@@ -1,8 +1,8 @@
 package io.ebeaninternal.dbmigration.ddlgeneration;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.config.ServerConfig;
+import io.ebean.DB;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebean.config.dbplatform.hana.HanaPlatform;
@@ -11,14 +11,14 @@ import io.ebean.config.dbplatform.sqlserver.SqlServer17Platform;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.dbmigration.migration.ChangeSet;
 import io.ebeaninternal.dbmigration.model.CurrentModel;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class BaseDdlHandlerTest extends BaseTestCase {
 
-  private ServerConfig serverConfig = new ServerConfig();
+  private final DatabaseConfig serverConfig = new DatabaseConfig();
 
   private DdlHandler handler(DatabasePlatform platform) {
     return PlatformDdlBuilder.create(platform).createDdlHandler(serverConfig);
@@ -223,11 +223,11 @@ public class BaseDdlHandlerTest extends BaseTestCase {
     assertThat(write.dropAll().getBuffer()).isEqualTo(rollbackLast);
   }
 
-  @Ignore
+  @Disabled
   @Test
   public void generateChangeSetFromModel() throws Exception {
 
-    SpiEbeanServer defaultServer = (SpiEbeanServer) Ebean.getDefaultServer();
+    SpiEbeanServer defaultServer = (SpiEbeanServer) DB.getDefault();
 
     ChangeSet createChangeSet = new CurrentModel(defaultServer).getChangeSet();
 
@@ -243,11 +243,10 @@ public class BaseDdlHandlerTest extends BaseTestCase {
     assertThat(write.dropAll().getBuffer()).isEqualTo(rollbackLast);
   }
 
-  @Ignore
+  @Disabled
   @Test
   public void generateChangeSetFromModel_given_postgresTypes() throws Exception {
-
-    SpiEbeanServer defaultServer = (SpiEbeanServer) Ebean.getDefaultServer();
+    SpiEbeanServer defaultServer = (SpiEbeanServer) DB.getDefault();
 
     ChangeSet createChangeSet = new CurrentModel(defaultServer).getChangeSet();
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/BaseTableDdlTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/BaseTableDdlTest.java
index c32d6ad80..d6af52969 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/BaseTableDdlTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/BaseTableDdlTest.java
@@ -1,36 +1,34 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
 
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.config.dbplatform.clickhouse.ClickHousePlatform;
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebean.config.dbplatform.mysql.MySqlPlatform;
 import io.ebean.config.dbplatform.oracle.OraclePlatform;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
 import io.ebeaninternal.dbmigration.ddlgeneration.Helper;
+import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
 import io.ebeaninternal.dbmigration.migration.AddTableComment;
 import io.ebeaninternal.dbmigration.migration.AlterColumn;
 import io.ebeaninternal.dbmigration.migration.Column;
 import io.ebeaninternal.dbmigration.migration.CreateTable;
-import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 
 public class BaseTableDdlTest {
 
-  private ServerConfig serverConfig = new ServerConfig();
-
-  private PlatformDdl h2ddl = PlatformDdlBuilder.create(new H2Platform());
+  private final DatabaseConfig serverConfig = new DatabaseConfig();
+  private final PlatformDdl h2ddl = PlatformDdlBuilder.create(new H2Platform());
 
   @Test
   public void testAlterColumn() throws IOException {
-
     BaseTableDdl ddlGen = new BaseTableDdl(serverConfig, h2ddl);
 
     DdlWrite write = new DdlWrite();
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/ClickHouseDbArrayTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/ClickHouseDbArrayTest.java
index 181630396..7e9dc946c 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/ClickHouseDbArrayTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/ClickHouseDbArrayTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DbNameNormaliseTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DbNameNormaliseTest.java
index d2c8e855c..bbdb51294 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DbNameNormaliseTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DbNameNormaliseTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
 import io.ebean.config.DbConstraintNormalise;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/H2HistoryDdlTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/H2HistoryDdlTest.java
index 87441f89e..a23a7ad79 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/H2HistoryDdlTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/H2HistoryDdlTest.java
@@ -1,15 +1,15 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.config.dbplatform.h2.H2Platform;
+import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlOptions;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
+import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
 import io.ebeaninternal.dbmigration.model.CurrentModel;
 import io.ebeaninternal.dbmigration.model.MConfiguration;
 import io.ebeaninternal.dbmigration.model.ModelContainer;
-import io.ebeaninternal.api.SpiEbeanServer;
-import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -19,7 +19,7 @@ public class H2HistoryDdlTest {
   @Test
   public void testRegenerateHistoryTriggers() throws Exception {
 
-    SpiEbeanServer ebeanServer = (SpiEbeanServer) Ebean.getDefaultServer();
+    SpiEbeanServer ebeanServer = (SpiEbeanServer) DB.getDefault();
 
     HistoryTableUpdate update = new HistoryTableUpdate("c_user");
     update.add(HistoryTableUpdate.Change.ADD, "one");
@@ -32,7 +32,7 @@ public class H2HistoryDdlTest {
 
     H2Platform h2Platform = new H2Platform();
     PlatformDdl h2Ddl = PlatformDdlBuilder.create(h2Platform);
-    h2Ddl.configure(ebeanServer.getServerConfig());
+    h2Ddl.configure(ebeanServer.config());
     h2Ddl.regenerateHistoryTriggers(write, update);
 
     assertThat(write.applyHistoryView().isEmpty()).isFalse();
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/HanaDdlTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/HanaDdlTest.java
index 6fc27e34d..3e467babe 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/HanaDdlTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/HanaDdlTest.java
@@ -3,11 +3,11 @@ package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 import io.ebean.config.dbplatform.hana.HanaPlatform;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
 import io.ebeaninternal.dbmigration.migration.Column;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class HanaDdlTest {
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/HistoryTableUpdateTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/HistoryTableUpdateTest.java
index 7e9e2e490..a2f2c6080 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/HistoryTableUpdateTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/HistoryTableUpdateTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/IndexSetTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/IndexSetTest.java
index ce91ab2e1..8a171b52e 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/IndexSetTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/IndexSetTest.java
@@ -1,10 +1,10 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
 import io.ebeaninternal.dbmigration.ddlgeneration.platform.util.IndexSet;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 
 public class IndexSetTest {
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/NativeDbArrayTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/NativeDbArrayTest.java
index 7d37363e4..3c609a2ba 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/NativeDbArrayTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/NativeDbArrayTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/OracleDdlTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/OracleDdlTest.java
index c9eb698ab..5d74e0b68 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/OracleDdlTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/OracleDdlTest.java
@@ -2,7 +2,7 @@ package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
 import io.ebean.annotation.ConstraintMode;
 import io.ebean.config.dbplatform.oracle.OraclePlatform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_AlterColumnTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_AlterColumnTest.java
index a696c4e62..5da1a25a8 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_AlterColumnTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_AlterColumnTest.java
@@ -14,14 +14,14 @@ import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
 import io.ebeaninternal.dbmigration.migration.AlterColumn;
 import io.ebeaninternal.dbmigration.migration.AlterForeignKey;
 import io.ebeaninternal.dbmigration.migration.Column;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class PlatformDdl_AlterColumnTest {
 
@@ -33,7 +33,7 @@ public class PlatformDdl_AlterColumnTest {
   private final PlatformDdl hanaDdl = PlatformDdlBuilder.create(new HanaPlatform());
 
   {
-    DatabaseConfig serverConfig = DB.getDefault().getPluginApi().getServerConfig();
+    DatabaseConfig serverConfig = DB.getDefault().pluginApi().config();
     sqlServerDdl.configure(serverConfig);
   }
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_CreateIndexTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_CreateIndexTest.java
index d7d33feae..e7b8fab30 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_CreateIndexTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_CreateIndexTest.java
@@ -10,10 +10,10 @@ import io.ebean.config.dbplatform.postgres.PostgresPlatform;
 import io.ebean.config.dbplatform.sqlserver.SqlServer17Platform;
 import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
 import io.ebeaninternal.dbmigration.migration.CreateIndex;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class PlatformDdl_CreateIndexTest {
 
@@ -25,7 +25,7 @@ public class PlatformDdl_CreateIndexTest {
   private final PlatformDdl hanaDdl = PlatformDdlBuilder.create(new HanaPlatform());
 
   {
-    DatabaseConfig config = DB.getDefault().getPluginApi().getServerConfig();
+    DatabaseConfig config = DB.getDefault().pluginApi().config();
     h2Ddl.configure(config);
     pgDdl.configure(config);
     mysqlDdl.configure(config);
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_dropUniqueConstraintTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_dropUniqueConstraintTest.java
index 3d345623b..00a6e271d 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_dropUniqueConstraintTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl_dropUniqueConstraintTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebean.config.dbplatform.hana.HanaPlatform;
 import io.ebean.config.dbplatform.mysql.MySqlPlatform;
@@ -8,18 +8,18 @@ import io.ebean.config.dbplatform.oracle.OraclePlatform;
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
 import io.ebean.config.dbplatform.sqlserver.SqlServer17Platform;
 import io.ebeaninternal.dbmigration.ddlgeneration.PlatformDdlBuilder;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class PlatformDdl_dropUniqueConstraintTest {
 
-  private PlatformDdl h2Ddl = PlatformDdlBuilder.create(new H2Platform());
-  private PlatformDdl pgDdl = PlatformDdlBuilder.create(new PostgresPlatform());
-  private PlatformDdl mysqlDdl = PlatformDdlBuilder.create(new MySqlPlatform());
-  private PlatformDdl oraDdl = PlatformDdlBuilder.create(new OraclePlatform());
-  private PlatformDdl sqlServerDdl = PlatformDdlBuilder.create(new SqlServer17Platform());
-  private PlatformDdl hanaDdl = PlatformDdlBuilder.create(new HanaPlatform());
+  private final PlatformDdl h2Ddl = PlatformDdlBuilder.create(new H2Platform());
+  private final PlatformDdl pgDdl = PlatformDdlBuilder.create(new PostgresPlatform());
+  private final PlatformDdl mysqlDdl = PlatformDdlBuilder.create(new MySqlPlatform());
+  private final PlatformDdl oraDdl = PlatformDdlBuilder.create(new OraclePlatform());
+  private final PlatformDdl sqlServerDdl = PlatformDdlBuilder.create(new SqlServer17Platform());
+  private final PlatformDdl hanaDdl = PlatformDdlBuilder.create(new HanaPlatform());
 
   @Test
   public void test() throws Exception {
@@ -39,8 +39,8 @@ public class PlatformDdl_dropUniqueConstraintTest {
     sql = mysqlDdl.alterTableDropUniqueConstraint("mytab", "uq_name");
     assertEquals("alter table mytab drop index uq_name", sql);
 
-    ServerConfig serverConfig = new ServerConfig();
-    hanaDdl.configure(serverConfig);
+    DatabaseConfig config = new DatabaseConfig();
+    hanaDdl.configure(config);
     sql = hanaDdl.alterTableDropUniqueConstraint("mytab", "uq_name");
     assertEquals("delimiter $$\n" +
         "do\n" +
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformTypeConverterTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformTypeConverterTest.java
index c6a9d1953..45dbd60b6 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformTypeConverterTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformTypeConverterTest.java
@@ -4,7 +4,7 @@ import io.ebean.config.dbplatform.DbPlatformTypeMapping;
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
 import io.ebeaninternal.dbmigration.ddlgeneration.platform.util.PlatformTypeConverter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PostgresDdlTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PostgresDdlTest.java
index 611ec94dd..3d12d29b7 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PostgresDdlTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PostgresDdlTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/SqlServerHistoryDdlTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/SqlServerHistoryDdlTest.java
index f1ac32365..73dd7c57f 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/SqlServerHistoryDdlTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/SqlServerHistoryDdlTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/util/VowelRemoverTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/util/VowelRemoverTest.java
index 894760ce8..46318bbbd 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/util/VowelRemoverTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/util/VowelRemoverTest.java
@@ -1,8 +1,8 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform.util;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class VowelRemoverTest {
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/migrationreader/MigrationXmlWriterTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/migrationreader/MigrationXmlWriterTest.java
index c0b87b47e..9805a263c 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/migrationreader/MigrationXmlWriterTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/migrationreader/MigrationXmlWriterTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.dbmigration.migrationreader;
 
 import io.ebeaninternal.dbmigration.migration.Migration;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.File;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/EntryTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/EntryTest.java
index df9657e5d..7c2fe8de1 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/EntryTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/EntryTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.dbmigration.model;
 import io.ebean.migration.MigrationVersion;
 import io.ebeaninternal.dbmigration.migration.ChangeSet;
 import io.ebeaninternal.dbmigration.migration.DropColumn;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MColumnTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MColumnTest.java
index 4cbd63cfa..29d01efdc 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MColumnTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MColumnTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.dbmigration.model;
 
 import io.ebeaninternal.dbmigration.migration.AlterColumn;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MTableIdentityTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MTableIdentityTest.java
index 5c76d62c0..7774d91c2 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MTableIdentityTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MTableIdentityTest.java
@@ -6,11 +6,12 @@ import io.ebeaninternal.dbmigration.migration.CreateTable;
 import io.ebeaninternal.dbmigration.migration.IdentityType;
 import io.ebeaninternal.server.deploy.IdentityMode;
 import io.ebeaninternal.server.deploy.meta.DeployIdentityMode;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.math.BigInteger;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class MTableIdentityTest {
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MTableTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MTableTest.java
index 290cff30a..f3e2d5648 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MTableTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MTableTest.java
@@ -6,13 +6,12 @@ import io.ebeaninternal.dbmigration.migration.AlterColumn;
 import io.ebeaninternal.dbmigration.migration.DropColumn;
 import io.ebeaninternal.dbmigration.migration.DropHistoryTable;
 import io.ebeaninternal.dbmigration.migration.DropTable;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class MTableTest {
 
@@ -155,27 +154,26 @@ public class MTableTest {
     assertThat(base.getColumn("name")).isNull();
   }
 
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void test_apply_dropColumn_doesNotExist() {
-
     MTable base = base();
 
     DropColumn dropColumn = new DropColumn();
     dropColumn.setTableName(base.getName());
     dropColumn.setColumnName("DoesNotExist");
-    base.apply(dropColumn);
+    assertThrows(IllegalStateException.class, () -> base.apply(dropColumn));
   }
 
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void test_apply_alterColumn_doesNotExist() {
-
     MTable base = base();
 
     AlterColumn alterColumn = new AlterColumn();
     alterColumn.setTableName(base.getName());
     alterColumn.setColumnName("DoesNotExist");
     alterColumn.setType("integer");
-    base.apply(alterColumn);
+
+    assertThrows(IllegalStateException.class, () ->  base.apply(alterColumn));
   }
 
   @Test
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MigrationVersionTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MigrationVersionTest.java
index 87a4fecd9..b3c4d5240 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MigrationVersionTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/MigrationVersionTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.dbmigration.model;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import io.ebean.migration.MigrationVersion;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelContainerApplyTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelContainerApplyTest.java
index 895b24f3f..da493f9ef 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelContainerApplyTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelContainerApplyTest.java
@@ -7,7 +7,7 @@ import io.ebeaninternal.dbmigration.migration.CreateTable;
 import io.ebeaninternal.dbmigration.migration.DropColumn;
 import io.ebeaninternal.dbmigration.migration.Migration;
 import io.ebeaninternal.dbmigration.migrationreader.MigrationXmlReader;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelContainerTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelContainerTest.java
index c9c1dc8c0..c76906fd1 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelContainerTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelContainerTest.java
@@ -7,7 +7,7 @@ import io.ebeaninternal.dbmigration.migration.DropIndex;
 import io.ebeaninternal.dbmigration.migration.DropTable;
 import io.ebeaninternal.dbmigration.migration.Migration;
 import io.ebeaninternal.dbmigration.migrationreader.MigrationXmlReader;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.Set;
@@ -158,7 +158,7 @@ public class ModelContainerTest {
   public void apply_renameColumn() {
     ModelContainer container = new ModelContainer();
     container.apply(mig("6.0__renameColumn.model.xml"), ver("6.0"));
-    
+
     final MTable table = container.getTable("document");
     assertThat(table.getColumn("title")).isNotNull();
     assertThat(table.getColumn("short_title")).isNull();
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelDiffTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelDiffTest.java
index e2cdde859..15245e921 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelDiffTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/ModelDiffTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.dbmigration.model;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/PendingDropsTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/PendingDropsTest.java
index df58fbc45..66e091aae 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/PendingDropsTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/PendingDropsTest.java
@@ -4,29 +4,29 @@ import io.ebean.migration.MigrationVersion;
 import io.ebeaninternal.dbmigration.migration.ChangeSet;
 import io.ebeaninternal.dbmigration.migration.DropColumn;
 import io.ebeaninternal.dbmigration.migration.Migration;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 
 public class PendingDropsTest {
 
   static final MigrationVersion V1_1 = MigrationVersion.parse("1.1");
-
   static final MigrationVersion V1_2 = MigrationVersion.parse("1.2");
 
   @Test
-  public void test_add() throws Exception {
+  public void test_add() {
 
     PendingDrops pendingDrops = new PendingDrops();
     pendingDrops.add(V1_1, new ChangeSet());
   }
 
   @Test
-  public void test_appliedDropsFor_when_matchesSome_then_removesMatched() throws Exception {
+  public void test_appliedDropsFor_when_matchesSome_then_removesMatched() {
 
     PendingDrops pendingDrops = new PendingDrops();
 
@@ -45,7 +45,7 @@ public class PendingDropsTest {
   }
 
   @Test
-  public void test_appliedDropsFor_when_matchesAll_then_removesChangeSet() throws Exception {
+  public void test_appliedDropsFor_when_matchesAll_then_removesChangeSet() {
 
     PendingDrops pendingDrops = new PendingDrops();
 
@@ -63,7 +63,7 @@ public class PendingDropsTest {
   }
 
   @Test
-  public void test_appliedDropsFor_when_changeSetSuppressed_isIgnored() throws Exception {
+  public void test_appliedDropsFor_when_changeSetSuppressed_isIgnored() {
 
     PendingDrops pendingDrops = new PendingDrops();
 
@@ -81,7 +81,7 @@ public class PendingDropsTest {
 
 
   @Test
-  public void test_pendingDrops() throws Exception {
+  public void test_pendingDrops() {
 
     PendingDrops pendingDrops = new PendingDrops();
     assertThat(pendingDrops.pendingDrops()).isEmpty();
@@ -92,7 +92,7 @@ public class PendingDropsTest {
   }
 
   @Test
-  public void test_pendingDrops_when_suppressForever() throws Exception {
+  public void test_pendingDrops_when_suppressForever() {
 
     PendingDrops pendingDrops = new PendingDrops();
     assertThat(pendingDrops.pendingDrops()).isEmpty();
@@ -105,7 +105,7 @@ public class PendingDropsTest {
   }
 
   @Test
-  public void test_pendingDrops_when_both() throws Exception {
+  public void test_pendingDrops_when_both() {
 
     PendingDrops pendingDrops = new PendingDrops();
     assertThat(pendingDrops.pendingDrops()).isEmpty();
@@ -119,7 +119,7 @@ public class PendingDropsTest {
   }
 
   @Test
-  public void test_migrationForVersion() throws Exception {
+  public void test_migrationForVersion() {
 
     PendingDrops pendingDrops = new PendingDrops();
 
@@ -137,7 +137,7 @@ public class PendingDropsTest {
   }
 
   @Test
-  public void test_migrationForVersion_when_both() throws Exception {
+  public void test_migrationForVersion_when_both() {
 
     PendingDrops pendingDrops = new PendingDrops();
 
@@ -153,7 +153,7 @@ public class PendingDropsTest {
   }
 
   @Test
-  public void test_migrationForVersion_when_next() throws Exception {
+  public void test_migrationForVersion_when_next() {
 
     PendingDrops pendingDrops = new PendingDrops();
     MigrationVersion version = V1_1;
@@ -168,32 +168,28 @@ public class PendingDropsTest {
     assertThat(pendingDrops.testContainsEntryFor(version)).isTrue();
   }
 
-  @Test(expected = IllegalArgumentException.class)
-  public void test_migrationForVersion_when_next_isSuppressForever() throws Exception {
-
+  @Test
+  public void test_migrationForVersion_when_next_isSuppressForever() {
     PendingDrops pendingDrops = new PendingDrops();
     pendingDrops.add(V1_1, newSuppressForeverChangeSet());
-    pendingDrops.migrationForVersion("next");
+    assertThrows(IllegalArgumentException.class, () ->  pendingDrops.migrationForVersion("next"));
   }
 
-  @Test(expected = IllegalArgumentException.class)
-  public void test_migrationForVersion_when_doesNotExist() throws Exception {
-
+  @Test
+  public void test_migrationForVersion_when_doesNotExist() {
     PendingDrops pendingDrops = new PendingDrops();
-    pendingDrops.migrationForVersion("1_1");
+    assertThrows(IllegalArgumentException.class, () ->  pendingDrops.migrationForVersion("1_1"));
   }
 
-  @Test(expected = IllegalArgumentException.class)
-  public void test_migrationForVersion_when_next_doesNotExist() throws Exception {
-
+  @Test
+  public void test_migrationForVersion_when_next_doesNotExist(){
     PendingDrops pendingDrops = new PendingDrops();
-    pendingDrops.migrationForVersion("next");
+    assertThrows(IllegalArgumentException.class, () -> pendingDrops.migrationForVersion("next"));
   }
 
 
   @Test
-  public void test_registerPendingHistoryDropColumns() throws Exception {
-
+  public void test_registerPendingHistoryDropColumns() {
     TDModelContainer modelContainer = new TDModelContainer();
 
     DropColumn drop1 = col("one");
@@ -210,7 +206,7 @@ public class PendingDropsTest {
     assertThat(modelContainer.drops).containsExactly(changeSet);
   }
 
-  class TDModelContainer extends ModelContainer {
+  static class TDModelContainer extends ModelContainer {
 
     List<ChangeSet> drops = new ArrayList<>();
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuildBeanVisitorTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuildBeanVisitorTest.java
index 3d94d859f..7c2e32b9d 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuildBeanVisitorTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuildBeanVisitorTest.java
@@ -15,7 +15,7 @@ import io.ebeaninternal.dbmigration.model.MCompoundForeignKey;
 import io.ebeaninternal.dbmigration.model.MTable;
 import io.ebeaninternal.dbmigration.model.ModelContainer;
 import io.ebeaninternal.dbmigration.model.visitor.VisitAllUsing;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.CKeyAssoc;
 import org.tests.model.basic.CKeyDetail;
 import org.tests.model.basic.CKeyParent;
@@ -34,7 +34,7 @@ public class ModelBuildBeanVisitorTest extends BaseTestCase {
 
     ModelContainer model = new ModelContainer();
 
-    DbConstraintNaming constraintNaming = defaultServer.getServerConfig().getConstraintNaming();
+    DbConstraintNaming constraintNaming = defaultServer.config().getConstraintNaming();
     constraintNaming.setMaxLength(new DefaultConstraintMaxLength(60));
     ModelBuildContext ctx = new ModelBuildContext(model, new H2Platform(), constraintNaming, true);
 
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_compoundKeyTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_compoundKeyTest.java
index 7db211782..3d95eb951 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_compoundKeyTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_compoundKeyTest.java
@@ -11,7 +11,7 @@ import io.ebeaninternal.dbmigration.migrationreader.MigrationXmlReader;
 import io.ebeaninternal.dbmigration.model.CurrentModel;
 import io.ebeaninternal.dbmigration.model.MTable;
 import io.ebeaninternal.dbmigration.model.ModelContainer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.CKeyAssoc;
 import org.tests.model.basic.CKeyDetail;
 import org.tests.model.basic.CKeyParent;
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_compound_IdClassTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_compound_IdClassTest.java
index fa435937a..6cd16314d 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_compound_IdClassTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_compound_IdClassTest.java
@@ -11,7 +11,7 @@ import io.ebeaninternal.dbmigration.migrationreader.MigrationXmlReader;
 import io.ebeaninternal.dbmigration.model.CurrentModel;
 import io.ebeaninternal.dbmigration.model.MTable;
 import io.ebeaninternal.dbmigration.model.ModelContainer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.CKeyAssoc;
 import org.tests.model.basic.CKeyDetail;
 import org.tests.model.basic.CKeyParent;
diff --git a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_explicitSequencesTest.java b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_explicitSequencesTest.java
index b65a1b061..07f29e34e 100644
--- a/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_explicitSequencesTest.java
+++ b/ebean-ddl-generator/src/test/java/io/ebeaninternal/dbmigration/model/build/ModelBuild_explicitSequencesTest.java
@@ -8,7 +8,7 @@ import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlOptions;
 import io.ebeaninternal.dbmigration.ddlgeneration.Helper;
 import io.ebeaninternal.dbmigration.model.CurrentModel;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Person;
 import org.tests.model.basic.Phone;
 
diff --git a/ebean-ddl-generator/src/test/java/org/tests/inheritance/company/domain/TestInheritAbstract.java b/ebean-ddl-generator/src/test/java/org/tests/inheritance/company/domain/TestInheritAbstract.java
index 4e4e5b64a..1fa9faf7b 100644
--- a/ebean-ddl-generator/src/test/java/org/tests/inheritance/company/domain/TestInheritAbstract.java
+++ b/ebean-ddl-generator/src/test/java/org/tests/inheritance/company/domain/TestInheritAbstract.java
@@ -1,28 +1,30 @@
 package org.tests.inheritance.company.domain;
 
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import junit.framework.TestCase;
-import org.junit.Assert;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
-public class TestInheritAbstract extends TestCase {
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
+public class TestInheritAbstract {
+
+  @Test
   public void testMe() {
-
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     List<AbstractBar> list0 = server.find(AbstractBar.class)
       .findList();
 
-    Assert.assertNotNull(list0);
+    assertNotNull(list0);
 
     List<AbstractBar> list1 = server.find(AbstractBar.class)
       .fetch("foo", "importantText")
       .findList();
 
-    Assert.assertNotNull(list1);
+    assertNotNull(list1);
 
     Foo f = new Foo();
     f.setImportantText("blah");
@@ -37,16 +39,14 @@ public class TestInheritAbstract extends TestCase {
       .fetch("foo", "importantText")
       .findList();
 
-    Assert.assertNotNull(list2);
-    Assert.assertTrue(!list2.isEmpty());
+    assertNotNull(list2);
+    assertThat(list2).isNotEmpty();
 
     for (AbstractBar abstractBar : list2) {
       Foo foo = abstractBar.getFoo();
       String importantText = foo.getImportantText();
-      Assert.assertNotNull(importantText);
+      assertNotNull(importantText);
     }
-
-
   }
 
 }
diff --git a/ebean-externalmapping-api/pom.xml b/ebean-externalmapping-api/pom.xml
index c2ea63651..25800d648 100644
--- a/ebean-externalmapping-api/pom.xml
+++ b/ebean-externalmapping-api/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <name>ebean external mapping api</name>
diff --git a/ebean-externalmapping-xml/pom.xml b/ebean-externalmapping-xml/pom.xml
index b62c33793..602bbbc60 100644
--- a/ebean-externalmapping-xml/pom.xml
+++ b/ebean-externalmapping-xml/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 <!--  <parent>-->
 <!--    <groupId>org.avaje</groupId>-->
@@ -14,7 +14,7 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-parent-12.8.0</tag>
+    <tag>ebean-parent-12.11.4</tag>
   </scm>
 
   <name>ebean external mapping xml</name>
@@ -33,7 +33,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-externalmapping-api</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
     </dependency>
 
     <dependency>
@@ -45,7 +45,7 @@
     <dependency>
       <groupId>io.avaje</groupId>
       <artifactId>classpath-scanner</artifactId>
-      <version>6.0</version>
+      <version>6.1</version>
     </dependency>
 
     <!-- test dependencies -->
@@ -59,21 +59,21 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-ddl-generator</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.composite</groupId>
+      <groupId>io.avaje</groupId>
       <artifactId>junit</artifactId>
-      <version>1.1</version>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
@@ -84,12 +84,12 @@
       <plugin>
         <groupId>io.repaint.maven</groupId>
         <artifactId>tiles-maven-plugin</artifactId>
-        <version>2.19</version>
+        <version>2.24</version>
         <extensions>true</extensions>
         <configuration>
           <tiles>
             <!-- other tiles ... -->
-            <tile>io.ebean.tile:enhancement:12.6.0</tile>
+            <tile>io.ebean.tile:enhancement:12.11.3</tile>
           </tiles>
         </configuration>
       </plugin>
diff --git a/ebean-externalmapping-xml/src/test/java/io/ebeaninternal/xmlmapping/model/XmlMappingReaderTest.java b/ebean-externalmapping-xml/src/test/java/io/ebeaninternal/xmlmapping/model/XmlMappingReaderTest.java
index b8586e3da..c76eda519 100644
--- a/ebean-externalmapping-xml/src/test/java/io/ebeaninternal/xmlmapping/model/XmlMappingReaderTest.java
+++ b/ebean-externalmapping-xml/src/test/java/io/ebeaninternal/xmlmapping/model/XmlMappingReaderTest.java
@@ -1,11 +1,11 @@
 package io.ebeaninternal.xmlmapping.model;
 
 import io.ebeaninternal.xmlmapping.XmlMappingReader;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.InputStream;
 
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class XmlMappingReaderTest {
 
diff --git a/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/BaseTestCase.java b/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/BaseTestCase.java
index 39427f5da..047c4a143 100644
--- a/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/BaseTestCase.java
+++ b/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/BaseTestCase.java
@@ -11,7 +11,7 @@ public class BaseTestCase {
   }
 
   protected Platform platform() {
-    return spiEbeanServer().getDatabasePlatform().getPlatform().base();
+    return spiEbeanServer().platform().base();
   }
 
   protected SpiEbeanServer spiEbeanServer() {
diff --git a/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/NamedDtoQueryTest.java b/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/NamedDtoQueryTest.java
index 86e40ee86..30a7c82a2 100644
--- a/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/NamedDtoQueryTest.java
+++ b/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/NamedDtoQueryTest.java
@@ -1,7 +1,7 @@
 package org.tests.model.basic.test;
 
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.CustDto;
 import org.tests.model.basic.Customer;
 
diff --git a/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/NamedLocalAndExternalTest.java b/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/NamedLocalAndExternalTest.java
index 61776857f..442f40269 100644
--- a/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/NamedLocalAndExternalTest.java
+++ b/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/NamedLocalAndExternalTest.java
@@ -3,7 +3,7 @@ package org.tests.model.basic.test;
 import io.ebean.DB;
 import io.ebean.Database;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/OrderAggregateNamedRawSqlTest.java b/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/OrderAggregateNamedRawSqlTest.java
index 578c4a6d3..f28f01fb9 100644
--- a/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/OrderAggregateNamedRawSqlTest.java
+++ b/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/OrderAggregateNamedRawSqlTest.java
@@ -3,7 +3,7 @@ package org.tests.model.basic.test;
 import io.ebean.DB;
 import io.ebean.Query;
 import org.assertj.core.api.AbstractCharSequenceAssert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.OrderAggregate;
 
 public class OrderAggregateNamedRawSqlTest {
diff --git a/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/RawSqlOrmQueryTest.java b/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/RawSqlOrmQueryTest.java
index 96667bb22..0e9350dc0 100644
--- a/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/RawSqlOrmQueryTest.java
+++ b/ebean-externalmapping-xml/src/test/java/org/tests/model/basic/test/RawSqlOrmQueryTest.java
@@ -2,7 +2,7 @@ package org.tests.model.basic.test;
 
 import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 
 import java.util.List;
diff --git a/ebean-postgis/pom.xml b/ebean-postgis/pom.xml
index 42b18f4f1..42a16dbaf 100644
--- a/ebean-postgis/pom.xml
+++ b/ebean-postgis/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <name>ebean postgis</name>
@@ -23,7 +23,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
 
@@ -74,7 +74,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-test</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
@@ -86,9 +86,9 @@
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.composite</groupId>
-      <artifactId>composite-testing</artifactId>
-      <version>3.1</version>
+      <groupId>io.avaje</groupId>
+      <artifactId>junit</artifactId>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
@@ -101,11 +101,11 @@
       <plugin>
         <groupId>io.repaint.maven</groupId>
         <artifactId>tiles-maven-plugin</artifactId>
-        <version>2.19</version>
+        <version>2.24</version>
         <extensions>true</extensions>
         <configuration>
           <tiles>
-            <tile>io.ebean.tile:enhancement:12.6.0</tile>
+            <tile>io.ebean.tile:enhancement:12.11.3</tile>
           </tiles>
         </configuration>
       </plugin>
diff --git a/ebean-postgis/src/test/java/org/example/domain/TestInsertQuery.java b/ebean-postgis/src/test/java/org/example/domain/TestInsertQuery.java
index e5aba6a5f..c12d1765e 100644
--- a/ebean-postgis/src/test/java/org/example/domain/TestInsertQuery.java
+++ b/ebean-postgis/src/test/java/org/example/domain/TestInsertQuery.java
@@ -1,13 +1,13 @@
 package org.example.domain;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.postgis.LineString;
 import org.postgis.MultiLineString;
 import org.postgis.MultiPoint;
 import org.postgis.MultiPolygon;
 import org.postgis.Point;
 import org.postgis.Polygon;
-import org.testng.annotations.Test;
 
 import java.sql.SQLException;
 import java.util.List;
@@ -17,16 +17,16 @@ public class TestInsertQuery {
   /**
    * Not automated this test yet.
    */
-  @Test(enabled = false)
+  @Test
   public void insert() throws SQLException {
 
 
-    List<MyBean> list = Ebean.find(MyBean.class).findList();
+    List<MyBean> list = DB.find(MyBean.class).findList();
     for (MyBean MyBean : list) {
       System.out.println(MyBean.getPoint());
     }
 
-    List<MyBean> list1 = Ebean.find(MyBean.class)
+    List<MyBean> list1 = DB.find(MyBean.class)
         .where()
         .raw("st_within(st_pointfromwkb(st_point(?, ?), 4674), poly)", 1.9, 1.9)
         .findList();
@@ -50,10 +50,10 @@ public class TestInsertQuery {
     p.setMultiPoint(multiPoint);
     p.setMpoly(mpoly);
 
-    Ebean.save(p);
+    DB.save(p);
 
     List<String> content =
-      Ebean.find(MyBean.class)
+      DB.find(MyBean.class)
       .select("ST_AsText(lineString)::String")
       .findSingleAttributeList();
 
diff --git a/ebean-postgis/src/test/java/org/example/domain/TestOtherInsertQuery.java b/ebean-postgis/src/test/java/org/example/domain/TestOtherInsertQuery.java
index 316ab4bc1..2596c8936 100644
--- a/ebean-postgis/src/test/java/org/example/domain/TestOtherInsertQuery.java
+++ b/ebean-postgis/src/test/java/org/example/domain/TestOtherInsertQuery.java
@@ -1,6 +1,6 @@
 package org.example.domain;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import org.geolatte.geom.Point;
 import org.geolatte.geom.Polygon;
 import org.geolatte.geom.codec.Wkt;
@@ -8,9 +8,9 @@ import org.geolatte.geom.LineString;
 import org.geolatte.geom.MultiLineString;
 import org.geolatte.geom.MultiPoint;
 import org.geolatte.geom.MultiPolygon;
-import org.testng.annotations.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
-import java.sql.SQLException;
 import java.util.List;
 
 public class TestOtherInsertQuery {
@@ -18,16 +18,16 @@ public class TestOtherInsertQuery {
   /**
    * Not automated this test yet.
    */
-  @Test(enabled = false)
-  public void insert() throws SQLException {
+  @Disabled
+  @Test
+  public void insert() {
 
-
-    List<OtherBeanGeoLatte> list = Ebean.find(OtherBeanGeoLatte.class).findList();
+    List<OtherBeanGeoLatte> list = DB.find(OtherBeanGeoLatte.class).findList();
     for (OtherBeanGeoLatte OtherBeanGeoLatte : list) {
       System.out.println(OtherBeanGeoLatte.getPoint());
     }
 
-    List<OtherBeanGeoLatte> list1 = Ebean.find(OtherBeanGeoLatte.class)
+    List<OtherBeanGeoLatte> list1 = DB.find(OtherBeanGeoLatte.class)
         .where()
         .raw("st_within(st_pointfromwkb(st_point(?, ?), 4674), poly)", 1.9, 1.9)
         .findList();
@@ -52,6 +52,6 @@ public class TestOtherInsertQuery {
     p.setMultiPoint(multiPoint);
     p.setMultiLineString(multiLineString);
 
-    Ebean.save(p);
+    DB.save(p);
   }
 }
diff --git a/ebean-postgis/src/test/java/org/example/domain/TestQuery.java b/ebean-postgis/src/test/java/org/example/domain/TestQuery.java
index 8fffb0047..b135d1709 100644
--- a/ebean-postgis/src/test/java/org/example/domain/TestQuery.java
+++ b/ebean-postgis/src/test/java/org/example/domain/TestQuery.java
@@ -10,13 +10,13 @@ import org.geolatte.geom.Point;
 import org.geolatte.geom.Polygon;
 import org.geolatte.geom.PositionSequenceBuilders;
 import org.geolatte.geom.crs.CoordinateReferenceSystems;
-import org.testng.annotations.AfterTest;
-import org.testng.annotations.BeforeTest;
-import org.testng.annotations.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import static org.geolatte.geom.codec.Wkt.toWkt;
-import static org.testng.Assert.assertNotNull;
-import static org.testng.AssertJUnit.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestQuery {
 
@@ -88,20 +88,17 @@ public class TestQuery {
     )
   );
 
-  @BeforeTest
+  @BeforeEach
   public void setupObjects() {
     OtherBeanGeoLatte geoLatte = new OtherBeanGeoLatte();
     geoLatte.setWgs84Point(wgs84Point);
     DB.save(geoLatte);
   }
 
-  @AfterTest
+  @AfterEach
   public void cleanup() {
-    DB
-      .find(MyBean.class)
-      .delete();
-    DB.find(OtherBeanGeoLatte.class)
-      .delete();
+    DB.find(MyBean.class).delete();
+    DB.find(OtherBeanGeoLatte.class).delete();
   }
 
   @Test
diff --git a/ebean-querybean/pom.xml b/ebean-querybean/pom.xml
index a91cdb4ef..02eb8f230 100644
--- a/ebean-querybean/pom.xml
+++ b/ebean-querybean/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <name>ebean querybean</name>
@@ -17,7 +17,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
 
@@ -28,7 +28,7 @@
     <dependency>
       <groupId>io.avaje</groupId>
       <artifactId>avaje-jsr305</artifactId>
-      <version>1.0</version>
+      <version>1.1</version>
       <scope>provided</scope>
     </dependency>
 
@@ -42,7 +42,7 @@
     <dependency>
       <groupId>javax.validation</groupId>
       <artifactId>validation-api</artifactId>
-      <version>1.0.0.GA</version>
+      <version>2.0.1.Final</version>
       <optional>true</optional>
     </dependency>
 
@@ -57,28 +57,28 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-ddl-generator</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>querybean-generator</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-test</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.composite</groupId>
+      <groupId>io.avaje</groupId>
       <artifactId>junit</artifactId>
-      <version>1.1</version>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
@@ -98,11 +98,11 @@
       <plugin>
         <groupId>io.repaint.maven</groupId>
         <artifactId>tiles-maven-plugin</artifactId>
-        <version>2.19</version>
+        <version>2.24</version>
         <extensions>true</extensions>
         <configuration>
           <tiles>
-            <tile>io.ebean.tile:enhancement:12.6.0</tile>
+            <tile>io.ebean.tile:enhancement:12.11.3</tile>
           </tiles>
         </configuration>
       </plugin>
diff --git a/ebean-querybean/src/main/java/io/ebean/typequery/PByteArray.java b/ebean-querybean/src/main/java/io/ebean/typequery/PByteArray.java
new file mode 100644
index 000000000..222215887
--- /dev/null
+++ b/ebean-querybean/src/main/java/io/ebean/typequery/PByteArray.java
@@ -0,0 +1,27 @@
+package io.ebean.typequery;
+
+/**
+ * Byte array property (<code>byte[]</code>).
+ *
+ * @param <R> the root query bean type
+ */
+public class PByteArray<R> extends PBaseValueEqual<R, byte[]> {
+  /**
+   * Construct with a property name and root instance.
+   *
+   * @param name property name
+   * @param root the root query bean instance
+   */
+  public PByteArray(String name, R root) {
+    super(name, root);
+  }
+
+  /**
+   * Construct with additional path prefix.
+   */
+  public PByteArray(String name, R root, String prefix) {
+    super(name, root, prefix);
+  }
+
+
+}
diff --git a/ebean-querybean/src/test/java/io/ebean/typequery/PBooleanTest.java b/ebean-querybean/src/test/java/io/ebean/typequery/PBooleanTest.java
index 283603c5f..365e5dc86 100644
--- a/ebean-querybean/src/test/java/io/ebean/typequery/PBooleanTest.java
+++ b/ebean-querybean/src/test/java/io/ebean/typequery/PBooleanTest.java
@@ -4,7 +4,7 @@ import io.ebeaninternal.server.expression.DefaultExpressionList;
 import io.ebeaninternal.server.expression.SimpleExpression;
 import org.example.domain.Customer;
 import org.example.domain.query.QCustomer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-querybean/src/test/java/org/example/domain/Customer.java b/ebean-querybean/src/test/java/org/example/domain/Customer.java
index 36d3fa840..453b71818 100644
--- a/ebean-querybean/src/test/java/org/example/domain/Customer.java
+++ b/ebean-querybean/src/test/java/org/example/domain/Customer.java
@@ -13,6 +13,7 @@ import javax.persistence.Entity;
 import javax.persistence.ManyToOne;
 import javax.persistence.OneToMany;
 import javax.persistence.Table;
+import javax.persistence.Lob;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
@@ -68,6 +69,9 @@ public class Customer extends BaseModel {
   @OneToMany(mappedBy = "customer", cascade = CascadeType.PERSIST)
   List<Contact> contacts;
 
+  @Column @Lob
+  byte[] photo;
+
   public Status getStatus() {
     return status;
   }
@@ -156,6 +160,14 @@ public class Customer extends BaseModel {
     this.email = email;
   }
 
+  public byte[] getPhoto() {
+    return photo;
+  }
+
+  public void setPhoto(byte[] photo) {
+    this.photo = photo;
+  }
+
   /**
    * Helper method to add a contact to the customer.
    */
diff --git a/ebean-querybean/src/test/java/org/querytest/FindNative_withSchema.java b/ebean-querybean/src/test/java/org/querytest/FindNative_withSchema.java
index 59146648d..db75b7541 100644
--- a/ebean-querybean/src/test/java/org/querytest/FindNative_withSchema.java
+++ b/ebean-querybean/src/test/java/org/querytest/FindNative_withSchema.java
@@ -5,7 +5,7 @@ import org.example.domain.Customer;
 import org.example.domain.Order;
 import org.example.domain.OrderDetail;
 import org.example.domain.Product;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
diff --git a/ebean-querybean/src/test/java/org/querytest/QContactTest.java b/ebean-querybean/src/test/java/org/querytest/QContactTest.java
index ef0d5a01b..296aa5be6 100644
--- a/ebean-querybean/src/test/java/org/querytest/QContactTest.java
+++ b/ebean-querybean/src/test/java/org/querytest/QContactTest.java
@@ -1,7 +1,7 @@
 package org.querytest;
 
 import org.example.domain.query.QContact;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.time.ZonedDateTime;
 
diff --git a/ebean-querybean/src/test/java/org/querytest/QCustomerAndOrTest.java b/ebean-querybean/src/test/java/org/querytest/QCustomerAndOrTest.java
index 231f4ae8d..b930c1509 100644
--- a/ebean-querybean/src/test/java/org/querytest/QCustomerAndOrTest.java
+++ b/ebean-querybean/src/test/java/org/querytest/QCustomerAndOrTest.java
@@ -1,7 +1,7 @@
 package org.querytest;
 
 import org.example.domain.Customer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
diff --git a/ebean-querybean/src/test/java/org/querytest/QCustomerByteArrayTest.java b/ebean-querybean/src/test/java/org/querytest/QCustomerByteArrayTest.java
new file mode 100644
index 000000000..2e796b606
--- /dev/null
+++ b/ebean-querybean/src/test/java/org/querytest/QCustomerByteArrayTest.java
@@ -0,0 +1,77 @@
+package org.querytest;
+
+import io.ebean.DB;
+import io.ebean.Database;
+import org.example.domain.Customer;
+import org.example.domain.query.QCustomer;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class QCustomerByteArrayTest {
+  @Test
+  public void testIsNull() {
+    final byte[] photo1 = new byte[]{0x05, 0x10, 0x20, 0x30};
+    final byte[] photo2 = new byte[]{0x50, 0x55, 0x60, 0x70, 0x10};
+    final Database db = DB.getDefault();
+    final String noPhoto = "no_photo_client";
+    final String wPhoto1 = "with_photo1_client";
+    final String wPhoto2 = "with_photo2_client";
+
+    Customer c;
+
+    c = new Customer();
+    c.setName(noPhoto);
+    c.save();
+
+    c = new Customer();
+    c.setName(wPhoto1);
+    c.setPhoto(photo1);
+    c.save();
+
+    c = new Customer();
+    c.setName(wPhoto2);
+    c.setPhoto(photo2);
+    c.save();
+
+    assertNotNull(new QCustomer(db).name.eq(noPhoto).photo.isNull().findOne());
+    //    Assert.assertNotNull(new QCustomer(db).name.eq(noPhoto).photo.ne(photo1).findOne()); // Fails
+    assertNull(new QCustomer(db).name.eq(noPhoto).photo.isNotNull().findOne());
+    assertNull(new QCustomer(db).name.eq(noPhoto).photo.eq(photo1).findOne());
+
+
+    assertNotNull(new QCustomer(db).name.eq(wPhoto1).photo.isNotNull().findOne());
+    assertNotNull(new QCustomer(db).name.eq(wPhoto1).photo.eq(photo1).findOne());
+    assertNotNull(new QCustomer(db).photo.eq(photo1).findOne());
+    assertNotNull(new QCustomer(db).name.eq(wPhoto1).photo.ne(photo2).findOne());
+
+    assertNull(new QCustomer(db).name.eq(wPhoto1).photo.isNull().findOne());
+    assertNull(new QCustomer(db).name.eq(wPhoto1).photo.eq(photo2).findOne());
+    assertNull(new QCustomer(db).name.eq(wPhoto1).photo.ne(photo1).findOne());
+
+    assertNotNull(new QCustomer(db).name.eq(wPhoto2).photo.isNotNull().findOne());
+    assertNotNull(new QCustomer(db).name.eq(wPhoto2).photo.eq(photo2).findOne());
+    assertNotNull(new QCustomer(db).photo.eq(photo2).findOne());
+    assertNotNull(new QCustomer(db).name.eq(wPhoto2).photo.ne(photo1).findOne());
+
+    assertNull(new QCustomer(db).name.eq(wPhoto2).photo.isNull().findOne());
+    assertNull(new QCustomer(db).name.eq(wPhoto2).photo.eq(photo1).findOne());
+    assertNull(new QCustomer(db).name.eq(wPhoto2).photo.ne(photo2).findOne());
+
+    assertEquals(2, new QCustomer(db).photo.in(photo1, photo2).findList().size());
+
+
+    List<Customer> ordered = new QCustomer(db).name.in(wPhoto1, wPhoto2).photo.desc().findList();
+    assertEquals(wPhoto2, ordered.get(0).getName());
+    assertArrayEquals(photo2, ordered.get(0).getPhoto());
+    assertEquals(wPhoto1, ordered.get(1).getName());
+    assertArrayEquals(photo1, ordered.get(1).getPhoto());
+
+    ordered = new QCustomer(db).name.in(wPhoto1, wPhoto2).photo.asc().findList();
+    assertEquals(wPhoto2, ordered.get(1).getName());
+    assertArrayEquals(photo2, ordered.get(1).getPhoto());
+    assertEquals(wPhoto1, ordered.get(0).getName());
+    assertArrayEquals(photo1, ordered.get(0).getPhoto());
+  }
+}
diff --git a/ebean-querybean/src/test/java/org/querytest/QCustomerSimpleLikeQueryTest.java b/ebean-querybean/src/test/java/org/querytest/QCustomerSimpleLikeQueryTest.java
index 182e2b737..6641e138b 100644
--- a/ebean-querybean/src/test/java/org/querytest/QCustomerSimpleLikeQueryTest.java
+++ b/ebean-querybean/src/test/java/org/querytest/QCustomerSimpleLikeQueryTest.java
@@ -2,7 +2,7 @@ package org.querytest;
 
 import org.example.domain.Customer;
 import org.example.domain.query.QCustomer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Date;
 import java.util.List;
diff --git a/ebean-querybean/src/test/java/org/querytest/QCustomerTest.java b/ebean-querybean/src/test/java/org/querytest/QCustomerTest.java
index 867290e71..09e768966 100644
--- a/ebean-querybean/src/test/java/org/querytest/QCustomerTest.java
+++ b/ebean-querybean/src/test/java/org/querytest/QCustomerTest.java
@@ -19,11 +19,8 @@ import org.example.domain.otherpackage.ValidEmail;
 import org.example.domain.query.QAnimal;
 import org.example.domain.query.QContact;
 import org.example.domain.query.QCustomer;
-import org.junit.Assert;
-import org.junit.Ignore;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TestName;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import javax.sql.DataSource;
 import java.sql.Connection;
@@ -46,12 +43,10 @@ import static org.example.domain.query.QAddress.Alias.country;
 import static org.example.domain.query.QAddress.Alias.line1;
 import static org.example.domain.query.QContact.Alias.lastName;
 import static org.example.domain.query.QCustomer.Alias.billingAddress;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class QCustomerTest {
 
-  @Rule
-  public final TestName testName = new TestName();
-
   @Test
   public void findWithTransaction() {
 
@@ -213,8 +208,7 @@ public class QCustomerTest {
       .findOne();
   }
 
-
-  @Ignore
+  @Disabled
   @Test
   public void arrayContains() {
 
@@ -277,7 +271,7 @@ public class QCustomerTest {
     cust.setStatus(Customer.Status.GOOD);
     cust.save();
 
-    DataSource dataSource = DB.getDefault().getDataSource();
+    DataSource dataSource = DB.getDefault().dataSource();
 
     try (Connection connection = dataSource.getConnection()) {
 
@@ -775,7 +769,7 @@ public class QCustomerTest {
   public void testFindSet() {
 
     Set<Customer> customerSet = new QCustomer().findSet();
-    Assert.assertNotNull(customerSet);
+    assertNotNull(customerSet);
   }
 
   @Test
@@ -831,11 +825,11 @@ public class QCustomerTest {
   @Test
   public void testFetchByScalarValue() {
     Customer cust = new Customer();
-    cust.setName(testName.getMethodName());
+    cust.setName("testFetchByScalarValue");
     cust.setPhoneNumber(new PhoneNumber("+18005555555"));
     cust.save();
     assertThat(new QCustomer()
-      .name.eq(testName.getMethodName())
+      .name.eq("testFetchByScalarValue")
       .phoneNumber.eq(new PhoneNumber("+18005555555"))
       .findOne()).isNotNull();
   }
@@ -844,23 +838,23 @@ public class QCustomerTest {
   @Test
   public void testFetchByComparableScalarValue() {
     Customer cust = new Customer();
-    cust.setName(testName.getMethodName());
+    cust.setName("testFetchByComparableScalarValue");
     cust.setEmail(new ValidEmail("foo2@example.org"));
     cust.save();
     assertThat(new QCustomer()
-      .name.eq(testName.getMethodName())
+      .name.eq("testFetchByComparableScalarValue")
       .email.eq(new ValidEmail("foo2@example.org"))
       .findOne()).isNotNull();
     assertThat(new QCustomer()
-      .name.eq(testName.getMethodName())
+      .name.eq("testFetchByComparableScalarValue")
       .email.gt(new ValidEmail("foo2@example.org"))
       .findOne()).isNull();
     assertThat(new QCustomer()
-      .name.eq(testName.getMethodName())
+      .name.eq("testFetchByComparableScalarValue")
       .email.gt(new ValidEmail("foo1@example.org"))
       .findOne()).isNotNull();
     assertThat(new QCustomer()
-      .name.eq(testName.getMethodName())
+      .name.eq("testFetchByComparableScalarValue")
       .email.greaterOrEqualTo(new ValidEmail("foo2@example.org"))
       .findOne()).isNotNull();
   }
diff --git a/ebean-querybean/src/test/java/org/querytest/QOrderTest.java b/ebean-querybean/src/test/java/org/querytest/QOrderTest.java
index db899549c..09ef00aa2 100644
--- a/ebean-querybean/src/test/java/org/querytest/QOrderTest.java
+++ b/ebean-querybean/src/test/java/org/querytest/QOrderTest.java
@@ -8,9 +8,9 @@ import org.example.domain.Order;
 import org.example.domain.otherpackage.PhoneNumber;
 import org.example.domain.query.QCustomer;
 import org.example.domain.query.QOrder;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -55,12 +55,12 @@ public class QOrderTest {
   private static Order order;
   private static Customer customer;
 
-  @BeforeClass
+  @BeforeAll
   public static void before() {
     setupData();
   }
 
-  @AfterClass
+  @AfterAll
   public static void after() {
     DB.delete(order);
     DB.delete(customer);
diff --git a/ebean-querybean/src/test/java/org/querytest/TargetTest.java b/ebean-querybean/src/test/java/org/querytest/TargetTest.java
index 8e83e5c05..9e3335b85 100644
--- a/ebean-querybean/src/test/java/org/querytest/TargetTest.java
+++ b/ebean-querybean/src/test/java/org/querytest/TargetTest.java
@@ -2,13 +2,13 @@ package org.querytest;
 
 import org.example.domain.query.QAreaImpl;
 import org.example.domain.query.QCityImpl;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class TargetTest {
 
   @Test
   public void test_oneToMany() {
-    
+
     new QAreaImpl()
       .cities.fetch()
       .findList();
diff --git a/ebean-redis/pom.xml b/ebean-redis/pom.xml
index 835a05812..0b8653312 100644
--- a/ebean-redis/pom.xml
+++ b/ebean-redis/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <artifactId>ebean-redis</artifactId>
@@ -22,42 +22,42 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-api</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-querybean</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>querybean-generator</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-test</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.composite</groupId>
+      <groupId>io.avaje</groupId>
       <artifactId>junit</artifactId>
-      <version>1.1</version>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
@@ -76,11 +76,11 @@
       <plugin>
         <groupId>io.repaint.maven</groupId>
         <artifactId>tiles-maven-plugin</artifactId>
-        <version>2.19</version>
+        <version>2.24</version>
         <extensions>true</extensions>
         <configuration>
           <tiles>
-            <tile>io.ebean.tile:enhancement:12.6.1</tile>
+            <tile>io.ebean.tile:enhancement:12.11.3</tile>
           </tiles>
         </configuration>
       </plugin>
diff --git a/ebean-redis/src/test/java/io/ebean/redis/RedisConfigTest.java b/ebean-redis/src/test/java/io/ebean/redis/RedisConfigTest.java
index 0b149bb87..35b757446 100644
--- a/ebean-redis/src/test/java/io/ebean/redis/RedisConfigTest.java
+++ b/ebean-redis/src/test/java/io/ebean/redis/RedisConfigTest.java
@@ -1,6 +1,6 @@
 package io.ebean.redis;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Properties;
 
diff --git a/ebean-redis/src/test/java/org/integration/ClusterTest.java b/ebean-redis/src/test/java/org/integration/ClusterTest.java
index 64c54baaa..6a8dc32ba 100644
--- a/ebean-redis/src/test/java/org/integration/ClusterTest.java
+++ b/ebean-redis/src/test/java/org/integration/ClusterTest.java
@@ -7,7 +7,7 @@ import io.ebean.Database;
 import io.ebean.DatabaseFactory;
 import io.ebean.config.DatabaseConfig;
 import org.domain.query.QPerson;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import javax.sql.DataSource;
 
@@ -30,7 +30,7 @@ public class ClusterTest {
   public void testBothNear() {
     // ensure the default server exists first
     final Database db = DB.getDefault();
-    Database other = createOther(db.getPluginApi().getDataSource());
+    Database other = createOther(db.pluginApi().dataSource());
 
     new QPerson()
       .name.eq("Someone")
@@ -39,13 +39,14 @@ public class ClusterTest {
     Person foo = new Person("Someone");
     foo.save();
 
-    DB.getServerCacheManager().clearAll();
-    other.getMetaInfoManager().resetAllMetrics();
+    DB.cacheManager().clearAll();
+    DB.getDefault().metaInfo().resetAllMetrics();
+    other.metaInfo().resetAllMetrics();
 
     Person fooA = DB.find(Person.class, foo.getId());
     Person fooB = other.find(Person.class, foo.getId());
 
-    DuelCache dualCacheA = (DuelCache) DB.getServerCacheManager().getBeanCache(Person.class);
+    DuelCache dualCacheA = (DuelCache) DB.cacheManager().beanCache(Person.class);
     assertCounts(dualCacheA, 0, 1, 0, 1);
     fooA = DB.find(Person.class, foo.getId());
     assertCounts(dualCacheA, 1, 1, 0, 1);
@@ -53,7 +54,7 @@ public class ClusterTest {
     fooA = DB.find(Person.class, foo.getId());
     assertCounts(dualCacheA, 2, 1, 0, 1);
     fooB = other.find(Person.class, foo.getId());
-    DuelCache dualCacheB = (DuelCache) other.getServerCacheManager().getBeanCache(Person.class);
+    DuelCache dualCacheB = (DuelCache) other.cacheManager().beanCache(Person.class);
     assertCounts(dualCacheB, 2, 1, 1, 0);
   }
 
@@ -61,17 +62,17 @@ public class ClusterTest {
   public void test() throws InterruptedException {
     // ensure the default server exists first
     final Database db = DB.getDefault();
-    Database other = createOther(db.getPluginApi().getDataSource());
+    Database other = createOther(db.pluginApi().dataSource());
 
     for (int i = 0; i < 10; i++) {
       Person foo = new Person("name " + i);
       foo.save();
     }
 
-    other.getServerCacheManager().clearAll();
-    other.getMetaInfoManager().resetAllMetrics();
+    other.cacheManager().clearAll();
+    other.metaInfo().resetAllMetrics();
 
-    DuelCache dualCache = (DuelCache) other.getServerCacheManager().getBeanCache(Person.class);
+    DuelCache dualCache = (DuelCache) other.cacheManager().beanCache(Person.class);
 
     Person foo0 = other.find(Person.class, 1);
     assertCounts(dualCache, 0, 1, 0, 1);
diff --git a/ebean-redis/src/test/java/org/integration/IntegrationTest.java b/ebean-redis/src/test/java/org/integration/IntegrationTest.java
index 5fb66aad6..646229d65 100644
--- a/ebean-redis/src/test/java/org/integration/IntegrationTest.java
+++ b/ebean-redis/src/test/java/org/integration/IntegrationTest.java
@@ -3,7 +3,7 @@ package org.integration;
 import io.ebean.DB;
 import org.domain.Person;
 import org.domain.query.QPerson;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.time.LocalDate;
 import java.util.ArrayList;
@@ -63,7 +63,7 @@ public class IntegrationTest {
 
     System.out.println("one2 " + one2);
 
-    DB.getServerCacheManager().clear(Person.class);
+    DB.cacheManager().clear(Person.class);
 
     System.out.println("done");
   }
diff --git a/ebean-test/pom.xml b/ebean-test/pom.xml
index 894f7f1b9..ecd8ebdb6 100644
--- a/ebean-test/pom.xml
+++ b/ebean-test/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <name>ebean test</name>
@@ -29,14 +29,14 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-ddl-generator</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
     </dependency>
 
     <dependency>
@@ -76,11 +76,74 @@
     <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
-      <version>1.4.200</version>
+      <version>1.4.199</version>
     </dependency>
 
     <!-- Test dependencies -->
 
+    <dependency>
+      <groupId>io.avaje</groupId>
+      <artifactId>avaje-jsr305</artifactId>
+      <version>1.0</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-migration</artifactId>
+      <version>12.4.0</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>io.avaje</groupId>
+      <artifactId>mod-uuid</artifactId>
+      <version>1.1</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.transaction</groupId>
+      <artifactId>jta</artifactId>
+      <version>1.1</version>
+      <scope>test</scope>
+    </dependency>
+
+    <!-- validation annotations Size etc -->
+    <dependency>
+      <groupId>javax.validation</groupId>
+      <artifactId>validation-api</artifactId>
+      <version>1.1.0.Final</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>jakarta.validation</groupId>
+      <artifactId>jakarta.validation-api</artifactId>
+      <version>3.0.0</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>joda-time</groupId>
+      <artifactId>joda-time</artifactId>
+      <version>2.9.7</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.annotation</groupId>
+      <artifactId>javax.annotation-api</artifactId>
+      <version>1.3.2</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>commons-io</groupId>
+      <artifactId>commons-io</artifactId>
+      <version>2.7</version>
+      <scope>test</scope>
+    </dependency>
+
     <dependency>
       <groupId>org.postgresql</groupId>
       <artifactId>postgresql</artifactId>
@@ -124,14 +187,28 @@
     </dependency>
 
     <dependency>
-      <groupId>junit</groupId>
+      <groupId>io.avaje</groupId>
       <artifactId>junit</artifactId>
-      <version>4.13.1</version>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
   </dependencies>
 
+  <profiles>
+    <profile>
+      <id>db2</id>
+      <dependencies>
+        <!-- https://mvnrepository.com/artifact/com.ibm.db2/jcc -->
+        <dependency>
+          <groupId>com.ibm.db2</groupId>
+          <artifactId>jcc</artifactId>
+          <version>11.5.5.0</version>
+          <scope>test</scope>
+        </dependency>
+      </dependencies>
+    </profile>
+  </profiles>
 
   <build>
     <plugins>
@@ -139,11 +216,11 @@
       <plugin>
         <groupId>io.repaint.maven</groupId>
         <artifactId>tiles-maven-plugin</artifactId>
-        <version>2.19</version>
+        <version>2.24</version>
         <extensions>true</extensions>
         <configuration>
           <tiles>
-            <tile>io.ebean.tile:enhancement:12.6.0</tile>
+            <tile>io.ebean.tile:enhancement:12.11.3</tile>
           </tiles>
         </configuration>
       </plugin>
diff --git a/ebean-core/src/test/java/io/ebean/BaseTestCase.java b/ebean-test/src/test/java/io/ebean/BaseTestCase.java
similarity index 83%
rename from ebean-core/src/test/java/io/ebean/BaseTestCase.java
rename to ebean-test/src/test/java/io/ebean/BaseTestCase.java
index 988e73b59..4f023c12e 100644
--- a/ebean-core/src/test/java/io/ebean/BaseTestCase.java
+++ b/ebean-test/src/test/java/io/ebean/BaseTestCase.java
@@ -17,10 +17,10 @@ import io.ebeaninternal.server.expression.platform.DbExpressionHandler;
 import io.ebeaninternal.server.expression.platform.DbExpressionHandlerFactory;
 import io.ebeaninternal.server.transaction.TransactionScopeManager;
 import org.assertj.core.api.AbstractCharSequenceAssert;
-import org.junit.After;
-import org.junit.Rule;
-import org.junit.rules.TestName;
-import org.junit.runner.RunWith;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.TestInfo;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Country;
@@ -30,23 +30,20 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
 
-@RunWith(ConditionalTestRunner.class)
+@ExtendWith(PlatformCondition.class)
 public abstract class BaseTestCase {
 
   protected static Logger logger = LoggerFactory.getLogger(BaseTestCase.class);
 
-  @Rule public TestName name = new TestName();
-
-  @After
-  public void checkForLeak() {
-    TransactionScopeManager scope = spiEbeanServer().getTransactionManager().scope();
+  @AfterEach
+  public void checkForLeak(TestInfo testInfo) {
+    TransactionScopeManager scope = spiEbeanServer().transactionManager().scope();
     SpiTransaction trans = scope.getInScope();
     if (trans != null) {
-      String msg = getClass().getSimpleName() + "." + name.getMethodName() + " did not clear threadScope:" + trans;
+      String msg = getClass().getSimpleName() + "." + testInfo.getDisplayName() + " did not clear threadScope:" + trans;
       scope.clearExternal(); // clear for next test
-      fail(msg);
+      Assertions.fail(msg);
     }
   }
 
@@ -78,15 +75,15 @@ public abstract class BaseTestCase {
   }
 
   protected void clearAllL2Cache() {
-    server().getServerCacheManager().clearAll();
+    server().cacheManager().clearAll();
   }
 
   protected void resetAllMetrics() {
-    server().getMetaInfoManager().resetAllMetrics();
+    server().metaInfo().resetAllMetrics();
   }
 
   protected ServerMetrics collectMetrics() {
-     return server().getMetaInfoManager().collectMetrics();
+     return server().metaInfo().collectMetrics();
   }
 
   protected List<MetaTimedMetric> visitTimedMetrics() {
@@ -102,7 +99,7 @@ public abstract class BaseTestCase {
   }
 
   protected SpiTransaction getInScopeTransaction() {
-    return spiEbeanServer().getTransactionManager().scope().getInScope();
+    return spiEbeanServer().transactionManager().scope().getInScope();
   }
 
   /**
@@ -167,7 +164,7 @@ public abstract class BaseTestCase {
   }
 
   public boolean isPlatformCaseSensitive() {
-    return spiEbeanServer().getDatabasePlatform().isCaseSensitiveCollation();
+    return spiEbeanServer().databasePlatform().isCaseSensitiveCollation();
   }
 
   /**
@@ -215,7 +212,7 @@ public abstract class BaseTestCase {
   }
 
   public boolean isPlatformBooleanNative() {
-    return Types.BOOLEAN == spiEbeanServer().getDatabasePlatform().getBooleanDbType();
+    return Types.BOOLEAN == spiEbeanServer().databasePlatform().getBooleanDbType();
   }
 
   public boolean isPlatformOrderNullsSupport() {
@@ -223,11 +220,11 @@ public abstract class BaseTestCase {
   }
 
   public boolean isPlatformSupportsDeleteTableAlias() {
-    return spiEbeanServer().getDatabasePlatform().isSupportsDeleteTableAlias();
+    return spiEbeanServer().databasePlatform().isSupportsDeleteTableAlias();
   }
 
   public boolean isPersistBatchOnCascade() {
-    return spiEbeanServer().getDatabasePlatform().getPersistBatchOnCascade() != PersistBatch.NONE;
+    return spiEbeanServer().databasePlatform().getPersistBatchOnCascade() != PersistBatch.NONE;
   }
 
   /**
@@ -238,27 +235,27 @@ public abstract class BaseTestCase {
   }
 
   protected <T> BeanDescriptor<T> getBeanDescriptor(Class<T> cls) {
-    return spiEbeanServer().getBeanDescriptor(cls);
+    return spiEbeanServer().descriptor(cls);
   }
 
   protected <T> ServerCacheStatistics getBeanCacheStats(Class<T> cls, boolean reset) {
-    return server().getServerCacheManager().getBeanCache(cls).getStatistics(reset);
+    return server().cacheManager().beanCache(cls).statistics(reset);
   }
 
   protected Platform platform() {
-    return spiEbeanServer().getDatabasePlatform().getPlatform().base();
+    return spiEbeanServer().databasePlatform().getPlatform().base();
   }
 
   protected IdType idType() {
-    return spiEbeanServer().getDatabasePlatform().getDbIdentity().getIdType();
+    return spiEbeanServer().databasePlatform().getDbIdentity().getIdType();
   }
 
   protected SpiEbeanServer spiEbeanServer() {
     return (SpiEbeanServer) DB.getDefault();
   }
 
-  protected EbeanServer server() {
-    return Ebean.getDefaultServer();
+  protected Database server() {
+    return DB.getDefault();
   }
 
   protected void loadCountryCache() {
@@ -299,7 +296,7 @@ public abstract class BaseTestCase {
   }
 
   protected String concat(String property0, String separator, String property1, String suffix) {
-    DbExpressionHandler dbExpressionHandler = DbExpressionHandlerFactory.from(spiEbeanServer().getDatabasePlatform());
+    DbExpressionHandler dbExpressionHandler = DbExpressionHandlerFactory.from(spiEbeanServer().databasePlatform());
     return dbExpressionHandler.concat(property0, separator, property1, suffix);
   }
 
diff --git a/ebean-core/src/test/java/io/ebean/ColumnTest.java b/ebean-test/src/test/java/io/ebean/ColumnTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebean/ColumnTest.java
rename to ebean-test/src/test/java/io/ebean/ColumnTest.java
index 9c8c1c50d..041e64efa 100644
--- a/ebean-core/src/test/java/io/ebean/ColumnTest.java
+++ b/ebean-test/src/test/java/io/ebean/ColumnTest.java
@@ -2,7 +2,7 @@ package io.ebean;
 
 
 import io.ebeaninternal.server.rawsql.SpiRawSql;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/DbPrimaryTest.java b/ebean-test/src/test/java/io/ebean/DbPrimaryTest.java
similarity index 81%
rename from ebean-core/src/test/java/io/ebean/DbPrimaryTest.java
rename to ebean-test/src/test/java/io/ebean/DbPrimaryTest.java
index 139f80930..eb94870d9 100644
--- a/ebean-core/src/test/java/io/ebean/DbPrimaryTest.java
+++ b/ebean-test/src/test/java/io/ebean/DbPrimaryTest.java
@@ -2,17 +2,14 @@ package io.ebean;
 
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Properties;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class DbPrimaryTest extends BaseTestCase {
 
-
   @Test
   public void testIsSkipPrimaryServer() {
     DbPrimary.setSkip(true);
@@ -24,14 +21,12 @@ public class DbPrimaryTest extends BaseTestCase {
   @Test
   @ForPlatform(Platform.H2)
   public void testGetPrimaryServerName() {
-
     String primaryServerName = DbPrimary.getDefaultServerName();
     assertEquals("h2", primaryServerName);
   }
 
   @Test
   public void testLoadProperties() {
-
     Properties properties = DbPrimary.getProperties();
     assertTrue(!properties.isEmpty());
   }
diff --git a/ebean-core/src/test/java/io/ebean/DtoQuery2Test.java b/ebean-test/src/test/java/io/ebean/DtoQuery2Test.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebean/DtoQuery2Test.java
rename to ebean-test/src/test/java/io/ebean/DtoQuery2Test.java
index 625cc9ae9..90a62f734 100644
--- a/ebean-core/src/test/java/io/ebean/DtoQuery2Test.java
+++ b/ebean-test/src/test/java/io/ebean/DtoQuery2Test.java
@@ -2,8 +2,8 @@ package io.ebean;
 
 import io.ebean.meta.BasicMetricVisitor;
 import io.ebean.meta.MetaQueryMetric;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Customer;
@@ -56,7 +56,7 @@ public class DtoQuery2Test extends BaseTestCase {
     ResetBasicData.reset();
     final int expectedCount = server().find(Customer.class).findCount();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     int counter = 0;
     try (final QueryIterator<DCust> iterator = server().findDto(DCust.class, "select id, name from o_customer where id > :id")
       .setParameter("id", 0)
@@ -72,7 +72,7 @@ public class DtoQuery2Test extends BaseTestCase {
 
     assertThat(counter).isEqualTo(expectedCount);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select id, name from o_customer where id > ?");
   }
 
@@ -81,7 +81,7 @@ public class DtoQuery2Test extends BaseTestCase {
     ResetBasicData.reset();
     final int expectedCount = server().find(Customer.class).findCount();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     try (final Stream<DCust> stream =
            server()
@@ -96,7 +96,7 @@ public class DtoQuery2Test extends BaseTestCase {
       assertThat(names.size()).isEqualTo(expectedCount);
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select id, name from o_customer where id > ?");
   }
 
@@ -105,12 +105,12 @@ public class DtoQuery2Test extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     server().findDto(DCust.class, "select id, name from o_customer where id > :id")
       .setParameter("id", 0)
       .findEach(it -> log.info("got " + it.getId() + " " + it.getName()));
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select id, name from o_customer where id > ?");
   }
 
@@ -119,7 +119,7 @@ public class DtoQuery2Test extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     server().findDto(DCust.class, "select id, name from o_customer where id > :id order by id desc")
       .setParameter("id", 0)
       .findEachWhile(customer -> {
@@ -127,7 +127,7 @@ public class DtoQuery2Test extends BaseTestCase {
         return customer.getId() > 3;
       });
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select id, name from o_customer where id > ?");
   }
 
@@ -189,7 +189,7 @@ public class DtoQuery2Test extends BaseTestCase {
 
     // collect without reset
     BasicMetricVisitor basic = new BasicMetricVisitor(false, true, true, true);
-    server().getMetaInfoManager().visitMetrics(basic);
+    server().metaInfo().visitMetrics(basic);
 
     List<MetaQueryMetric> stats = basic.queryMetrics();
     assertThat(stats).hasSize(1);
@@ -205,7 +205,7 @@ public class DtoQuery2Test extends BaseTestCase {
       .setParameter("name", "rob")
       .findList();
 
-    BasicMetricVisitor metric2 = server().getMetaInfoManager().visitBasic();
+    BasicMetricVisitor metric2 = server().metaInfo().visitBasic();
 
     stats = metric2.queryMetrics();
     assertThat(stats).hasSize(2);
diff --git a/ebean-core/src/test/java/io/ebean/DtoQueryFromOrmTest.java b/ebean-test/src/test/java/io/ebean/DtoQueryFromOrmTest.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebean/DtoQueryFromOrmTest.java
rename to ebean-test/src/test/java/io/ebean/DtoQueryFromOrmTest.java
index 28b0bd490..f850e3e0b 100644
--- a/ebean-core/src/test/java/io/ebean/DtoQueryFromOrmTest.java
+++ b/ebean-test/src/test/java/io/ebean/DtoQueryFromOrmTest.java
@@ -5,10 +5,10 @@ import io.ebean.annotation.Platform;
 import io.ebean.meta.MetaQueryMetric;
 import io.ebean.meta.MetaTimedMetric;
 import io.ebean.meta.ServerMetrics;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.ResetBasicData;
 
@@ -19,14 +19,14 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class DtoQueryFromOrmTest extends BaseTestCase {
 
-  @BeforeClass
+  @BeforeAll
   public static void resetStats() {
-    DB.getDefault().getMetaInfoManager().resetAllMetrics();
+    DB.getDefault().metaInfo().resetAllMetrics();
   }
 
-  @AfterClass
+  @AfterAll
   public static void reportStats() {
-    ServerMetrics metrics = DB.getDefault().getMetaInfoManager().collectMetrics();
+    ServerMetrics metrics = DB.getDefault().metaInfo().collectMetrics();
     for (MetaQueryMetric metric : metrics.queryMetrics()) {
       System.out.println(metric);
     }
@@ -76,7 +76,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Contact> list = DB.find(Contact.class)
       .select("email, concat(lastName, ISO_WEEK(?)) as lastName")
@@ -86,7 +86,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 
     assertThat(list).isNotEmpty();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.id, t0.email, concat(t0.last_name, ISO_WEEK(?)) lastName from contact");
   }
@@ -97,7 +97,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 //
 //    ResetBasicData.reset();
 //
-//    LoggedSqlCollector.start();
+//    LoggedSql.start();
 //
 //    List<Contact> list = DB.find(Contact.class)
 //      .select("email, concat(lastName, ISO_WEEK(:date)) as lastName")
@@ -108,7 +108,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 //
 //    assertThat(list).isNotEmpty();
 //
-//    List<String> sql = LoggedSqlCollector.stop();
+//    List<String> sql = LoggedSql.stop();
 //    assertThat(sql).hasSize(2);
 //    assertSql(sql.get(0)).contains("select t0.id, t0.email, concat(t0.last_name, ISO_WEEK(?)) lastName from contact");
 //  }
@@ -118,7 +118,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DtoQuery<ContactDto> query = DB.find(Contact.class)
       // we must explicitly add the id property for DTO query (if we want it)
@@ -135,7 +135,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
       assertThat(dto.getFullName()).isNotNull();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select t0.id, t0.email, " + concat("t0.last_name", ", ", "t0.first_name")
       + " fullName from contact t0 where t0.email is not null and t0.last_name is not null order by t0.last_name");
   }
@@ -145,7 +145,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DtoQuery<ContactDto2> query = DB.find(Contact.class)
       .where().isNotNull("email").order().asc("lastName")
@@ -162,7 +162,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
       assertThat(dto.getId()).isGreaterThan(0);
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select t0.id, t0.first_name, t0.last_name");
   }
 
@@ -171,7 +171,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DtoQuery<ContactDto> query = DB.find(Contact.class)
       .select("email, " + concat("lastName", ", ", "firstName") + " as fullName").where().isNotNull("email")
@@ -186,7 +186,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
       assertThat(dto.getFullName()).isNotNull();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select t0.email, " + concat("t0.last_name", ", ", "t0.first_name")
       + " fullName from contact t0 where t0.email is not null and t0.last_name is not null order by t0.last_name");
   }
@@ -196,7 +196,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<ContactDto> contactDtos = DB.find(Contact.class).setLabel("emailFullName")
       .select("email, " + concat("lastName", ", ", "firstName") + " as fullName").where().isNotNull("email")
@@ -209,7 +209,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
       assertThat(dto.getFullName()).isNotNull();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     if (isSqlServer()) {
       assertSql(sql.get(0)).contains("select top 10 t0.email, " + concat("t0.last_name", ", ", "t0.first_name")
@@ -226,7 +226,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<ContactDto> contactDtos = DB.find(Contact.class)
       .select("id, email, " + concat("lastName", ", ", "firstName") + " as fullName").where().isNotNull("email")
@@ -240,7 +240,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
       assertThat(dto.getEmail()).isNotNull();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     if (isSqlServer()) {
       assertSql(sql.get(0)).contains("select top 10 t0.id, t0.email, "
         + concat("t0.last_name", ", ", "t0.first_name")
@@ -256,7 +256,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<ContactDto> contactDtos = DB.find(Contact.class)
       .select(concat("lastName", ", ", "firstName") + " as fullName").where().isNotNull("lastName").order()
@@ -270,7 +270,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
       assertThat(dto.getEmail()).isNull();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select " + concat("t0.last_name", ", ", "t0.first_name") + " fullName from contact t0 where");
   }
 
@@ -279,7 +279,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<ContactTotals> contactDtos = DB.find(Contact.class).select("lastName, count(*) as totalCount").where()
       .isNotNull("lastName").having().gt("count(*)", 1).order().desc("count(*)").asDto(ContactTotals.class)
@@ -292,7 +292,7 @@ public class DtoQueryFromOrmTest extends BaseTestCase {
       assertThat(dto.getTotalCount()).isNotNull();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select t0.last_name, count(*) totalCount from contact t0 where t0.last_name is not null group by t0.last_name having count(*) > ?");
   }
 
diff --git a/ebean-core/src/test/java/io/ebean/DtoQueryTest.java b/ebean-test/src/test/java/io/ebean/DtoQueryTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebean/DtoQueryTest.java
rename to ebean-test/src/test/java/io/ebean/DtoQueryTest.java
index 0331a8215..53b2b4ca4 100644
--- a/ebean-core/src/test/java/io/ebean/DtoQueryTest.java
+++ b/ebean-test/src/test/java/io/ebean/DtoQueryTest.java
@@ -5,8 +5,8 @@ import io.ebean.annotation.Platform;
 import io.ebean.meta.BasicMetricVisitor;
 import io.ebean.meta.MetaQueryMetric;
 import io.ebean.meta.ServerMetrics;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Customer;
@@ -57,12 +57,12 @@ public class DtoQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     server().findDto(DCust.class, "select id, name from o_customer where id > :id")
       .setParameter("id", 0)
       .findEach(it -> log.info("got " + it.getId() + " " + it.getName()));
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select id, name from o_customer where id > ?");
   }
 
@@ -71,7 +71,7 @@ public class DtoQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     server().findDto(DCust.class, "select id, name from o_customer where id > :id order by id desc")
       .setParameter("id", 0)
       .findEachWhile(customer -> {
@@ -79,7 +79,7 @@ public class DtoQueryTest extends BaseTestCase {
         return customer.getId() > 3;
       });
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select id, name from o_customer where id > ?");
   }
 
@@ -281,7 +281,7 @@ public class DtoQueryTest extends BaseTestCase {
 
     // collect without reset
     BasicMetricVisitor basic = new BasicMetricVisitor(false, true, true, true);
-    server().getMetaInfoManager().visitMetrics(basic);
+    server().metaInfo().visitMetrics(basic);
 
     List<MetaQueryMetric> stats = basic.queryMetrics();
     assertThat(stats).hasSize(1);
@@ -297,7 +297,7 @@ public class DtoQueryTest extends BaseTestCase {
       .setParameter("name", "rob")
       .findList();
 
-    ServerMetrics metric2 = server().getMetaInfoManager().collectMetrics();
+    ServerMetrics metric2 = server().metaInfo().collectMetrics();
 
     stats = metric2.queryMetrics();
     assertThat(stats).hasSize(2);
diff --git a/ebean-core/src/test/java/io/ebean/EbeanServerFactory_MultiTenancy_Test.java b/ebean-test/src/test/java/io/ebean/EbeanServerFactory_MultiTenancy_Test.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebean/EbeanServerFactory_MultiTenancy_Test.java
rename to ebean-test/src/test/java/io/ebean/EbeanServerFactory_MultiTenancy_Test.java
index cbf119fb2..00f395f36 100644
--- a/ebean-core/src/test/java/io/ebean/EbeanServerFactory_MultiTenancy_Test.java
+++ b/ebean-test/src/test/java/io/ebean/EbeanServerFactory_MultiTenancy_Test.java
@@ -1,14 +1,9 @@
 package io.ebean;
 
-import io.ebean.config.CurrentTenantProvider;
-import io.ebean.config.DatabaseConfig;
-import io.ebean.config.TenantCatalogProvider;
-import io.ebean.config.TenantDataSourceProvider;
-import io.ebean.config.TenantMode;
-import io.ebean.config.TenantSchemaProvider;
+import io.ebean.config.*;
 import io.ebean.config.dbplatform.mysql.MySqlPlatform;
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
 import javax.sql.DataSource;
diff --git a/ebean-core/src/test/java/io/ebean/EbeanServerFactory_ServerConfigStart_Test.java b/ebean-test/src/test/java/io/ebean/EbeanServerFactory_ServerConfigStart_Test.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebean/EbeanServerFactory_ServerConfigStart_Test.java
rename to ebean-test/src/test/java/io/ebean/EbeanServerFactory_ServerConfigStart_Test.java
index 4c594630e..3946de7dd 100644
--- a/ebean-core/src/test/java/io/ebean/EbeanServerFactory_ServerConfigStart_Test.java
+++ b/ebean-test/src/test/java/io/ebean/EbeanServerFactory_ServerConfigStart_Test.java
@@ -2,7 +2,7 @@ package io.ebean;
 
 import io.ebean.config.DatabaseConfig;
 import io.ebean.event.ServerConfigStartup;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UTDetail;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -36,7 +36,7 @@ public class EbeanServerFactory_ServerConfigStart_Test {
 
     assertThat(db).isNotNull();
 
-    // test server shutdown and restart using the same ServerConfig
+    // test server shutdown and restart using the same DatabaseConfig
     db.shutdown(true, false);
 
     Database restartedServer = DatabaseFactory.create(config);
diff --git a/ebean-core/src/test/java/io/ebean/EbeanServer_deleteAllByIdTest.java b/ebean-test/src/test/java/io/ebean/EbeanServer_deleteAllByIdTest.java
similarity index 84%
rename from ebean-core/src/test/java/io/ebean/EbeanServer_deleteAllByIdTest.java
rename to ebean-test/src/test/java/io/ebean/EbeanServer_deleteAllByIdTest.java
index 6ab6db3e7..61c9031d0 100644
--- a/ebean-core/src/test/java/io/ebean/EbeanServer_deleteAllByIdTest.java
+++ b/ebean-test/src/test/java/io/ebean/EbeanServer_deleteAllByIdTest.java
@@ -1,14 +1,14 @@
 package io.ebean;
 
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 
 public class EbeanServer_deleteAllByIdTest extends BaseTestCase {
@@ -20,7 +20,7 @@ public class EbeanServer_deleteAllByIdTest extends BaseTestCase {
     final EBasicVer bean1 = bean("foo1");
     final EBasicVer bean2 = bean("foo2");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.saveAll(bean0, bean1, bean2);
 
@@ -28,7 +28,7 @@ public class EbeanServer_deleteAllByIdTest extends BaseTestCase {
     assertNotNull(bean1.getId());
     assertNotNull(bean2.getId());
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(4);
     assertThat(loggedSql.get(0)).contains("insert into e_basicver");
     assertSqlBind(loggedSql, 1, 3);
@@ -52,10 +52,10 @@ public class EbeanServer_deleteAllByIdTest extends BaseTestCase {
     }
 
     // act
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.deleteAll(EBasicVer.class, ids);
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     platformAssertIn(loggedSql.get(0), "delete from e_basicver where id ");
   }
@@ -73,12 +73,12 @@ public class EbeanServer_deleteAllByIdTest extends BaseTestCase {
 
     Database db = DB.getDefault();
     // act
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     try (Transaction txn = db.beginTransaction()) {
       db.deleteAll(EBasicVer.class, ids, txn);
       txn.commit();
     }
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     platformAssertIn(loggedSql.get(0), "delete from e_basicver where id ");
   }
@@ -94,11 +94,11 @@ public class EbeanServer_deleteAllByIdTest extends BaseTestCase {
       ids.add(someBean.getId());
     }
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.deleteAllPermanent(EBasicVer.class, ids);
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     platformAssertIn(loggedSql.get(0), "delete from e_basicver where id ");
   }
@@ -117,12 +117,12 @@ public class EbeanServer_deleteAllByIdTest extends BaseTestCase {
 
     Database db = DB.getDefault();
     // act
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     try (Transaction txn = db.beginTransaction()) {
       db.deleteAllPermanent(EBasicVer.class, ids, txn);
       txn.commit();
     }
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     platformAssertIn(loggedSql.get(0), "delete from e_basicver where id ");
   }
diff --git a/ebean-core/src/test/java/io/ebean/EbeanServer_deleteByIdTest.java b/ebean-test/src/test/java/io/ebean/EbeanServer_deleteByIdTest.java
similarity index 67%
rename from ebean-core/src/test/java/io/ebean/EbeanServer_deleteByIdTest.java
rename to ebean-test/src/test/java/io/ebean/EbeanServer_deleteByIdTest.java
index 43c4d750e..d86dc382d 100644
--- a/ebean-core/src/test/java/io/ebean/EbeanServer_deleteByIdTest.java
+++ b/ebean-test/src/test/java/io/ebean/EbeanServer_deleteByIdTest.java
@@ -1,8 +1,8 @@
 package io.ebean;
 
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -15,13 +15,13 @@ public class EbeanServer_deleteByIdTest extends BaseTestCase {
   public void deleteById() {
 
     EBasicVer someBean = bean("foo1");
-    Ebean.save(someBean);
+    DB.save(someBean);
 
     // act
-    LoggedSqlCollector.start();
-    Ebean.delete(EBasicVer.class, someBean.getId());
+    LoggedSql.start();
+    DB.delete(EBasicVer.class, someBean.getId());
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("delete from e_basicver where id = ?");
   }
@@ -30,13 +30,13 @@ public class EbeanServer_deleteByIdTest extends BaseTestCase {
   public void deletePermanentById() {
 
     EBasicVer someBean = bean("foo1");
-    Ebean.save(someBean);
+    DB.save(someBean);
 
     // act
-    LoggedSqlCollector.start();
-    Ebean.deletePermanent(EBasicVer.class, someBean.getId());
+    LoggedSql.start();
+    DB.deletePermanent(EBasicVer.class, someBean.getId());
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("delete from e_basicver where id = ?");
   }
@@ -46,11 +46,11 @@ public class EbeanServer_deleteByIdTest extends BaseTestCase {
   public void deleteById_withTransaction() {
 
     EBasicVer someBean = bean("foo1");
-    Ebean.save(someBean);
+    DB.save(someBean);
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     // act
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     Transaction txn = server.beginTransaction();
     try {
       server.delete(EBasicVer.class, someBean.getId(), txn);
@@ -58,7 +58,7 @@ public class EbeanServer_deleteByIdTest extends BaseTestCase {
     } finally {
       txn.end();
     }
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("delete from e_basicver where id = ?");
   }
@@ -67,11 +67,11 @@ public class EbeanServer_deleteByIdTest extends BaseTestCase {
   public void deletePermanentById_withTransaction() {
 
     EBasicVer someBean = bean("foo2");
-    Ebean.save(someBean);
+    DB.save(someBean);
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     // act
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     Transaction txn = server.beginTransaction();
     try {
       server.deletePermanent(EBasicVer.class, someBean.getId(), txn);
@@ -79,7 +79,7 @@ public class EbeanServer_deleteByIdTest extends BaseTestCase {
     } finally {
       txn.end();
     }
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("delete from e_basicver where id = ?");
   }
diff --git a/ebean-core/src/test/java/io/ebean/EbeanServer_deleteTest.java b/ebean-test/src/test/java/io/ebean/EbeanServer_deleteTest.java
similarity index 70%
rename from ebean-core/src/test/java/io/ebean/EbeanServer_deleteTest.java
rename to ebean-test/src/test/java/io/ebean/EbeanServer_deleteTest.java
index 92232e6f0..10ed5fbb9 100644
--- a/ebean-core/src/test/java/io/ebean/EbeanServer_deleteTest.java
+++ b/ebean-test/src/test/java/io/ebean/EbeanServer_deleteTest.java
@@ -1,8 +1,8 @@
 package io.ebean;
 
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -15,13 +15,13 @@ public class EbeanServer_deleteTest extends BaseTestCase  {
   public void delete() {
 
     EBasicVer someBean = bean("foo1");
-    Ebean.save(someBean);
+    DB.save(someBean);
 
     // act
-    LoggedSqlCollector.start();
-    Ebean.delete(someBean);
+    LoggedSql.start();
+    DB.delete(someBean);
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("delete from e_basicver where id=? and ");
   }
@@ -30,11 +30,11 @@ public class EbeanServer_deleteTest extends BaseTestCase  {
   public void delete_withTransaction() {
 
     EBasicVer someBean = bean("foo1");
-    Ebean.save(someBean);
+    DB.save(someBean);
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     // act
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     Transaction txn = server.beginTransaction();
     try {
       server.delete(someBean, txn);
@@ -42,7 +42,7 @@ public class EbeanServer_deleteTest extends BaseTestCase  {
     } finally {
       txn.end();
     }
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("delete from e_basicver where id=? and ");
   }
diff --git a/ebean-core/src/test/java/io/ebean/EbeanServer_eqlTest.java b/ebean-test/src/test/java/io/ebean/EbeanServer_eqlTest.java
similarity index 87%
rename from ebean-core/src/test/java/io/ebean/EbeanServer_eqlTest.java
rename to ebean-test/src/test/java/io/ebean/EbeanServer_eqlTest.java
index 0e3366311..c913e8495 100644
--- a/ebean-core/src/test/java/io/ebean/EbeanServer_eqlTest.java
+++ b/ebean-test/src/test/java/io/ebean/EbeanServer_eqlTest.java
@@ -1,7 +1,7 @@
 package io.ebean;
 
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -9,6 +9,7 @@ import javax.persistence.PersistenceException;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class EbeanServer_eqlTest extends BaseTestCase {
 
@@ -37,7 +38,7 @@ public class EbeanServer_eqlTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.createQuery(Customer.class, "order by id limit 10");
+    Query<Customer> query = DB.createQuery(Customer.class, "order by id limit 10");
     query.findList();
 
     if (isSqlServer()) {
@@ -55,7 +56,7 @@ public class EbeanServer_eqlTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.createQuery(Customer.class, "order by id limit 10 offset 3");
+    Query<Customer> query = DB.createQuery(Customer.class, "order by id limit 10 offset 3");
     query.findList();
 
     if (isSqlServer()) {
@@ -73,7 +74,7 @@ public class EbeanServer_eqlTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.createQuery(Customer.class, "order by name");
+    Query<Customer> query = DB.createQuery(Customer.class, "order by name");
     query.setMaxRows(10);
     query.setFirstRow(3);
     query.findList();
@@ -87,9 +88,9 @@ public class EbeanServer_eqlTest extends BaseTestCase {
     }
 
     // check also select count(*)
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.findCount();
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql.get(0)).startsWith("select count(*) from o_customer t0;");
   }
 
@@ -98,7 +99,7 @@ public class EbeanServer_eqlTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.createQuery(Customer.class, "order by name");
+    Query<Customer> query = DB.createQuery(Customer.class, "order by name");
     query.setMaxRows(10);
     query.setFirstRow(3);
     query.orderById(true);
@@ -113,9 +114,9 @@ public class EbeanServer_eqlTest extends BaseTestCase {
     }
 
     // check also select count(*)
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.findCount();
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql.get(0)).startsWith("select count(*) from o_customer t0;");
 
   }
@@ -125,7 +126,7 @@ public class EbeanServer_eqlTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.createQuery(Customer.class);
+    Query<Customer> query = DB.createQuery(Customer.class);
     query.setMaxRows(10);
     query.setFirstRow(3);
     if (isSqlServer()) {
@@ -147,7 +148,7 @@ public class EbeanServer_eqlTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.createQuery(Customer.class);
+    Query<Customer> query = DB.createQuery(Customer.class);
     query.setMaxRows(10);
     query.findList();
 
@@ -187,16 +188,14 @@ public class EbeanServer_eqlTest extends BaseTestCase {
     assertSql(query).contains("where t0.name like ");
   }
 
-  @Test(expected = PersistenceException.class)
+  @Test
   public void unboundNamedParams_expect_PersistenceException() {
-
     Query<Customer> query = server().createQuery(Customer.class, "where name = :name");
-    query.findOne();
+    assertThrows(PersistenceException.class, () ->query.findOne());
   }
 
   @Test
   public void namedQuery() {
-
     ResetBasicData.reset();
 
     Query<Customer> name = server().createNamedQuery(Customer.class, "name");
diff --git a/ebean-core/src/test/java/io/ebean/EbeanServer_refresh.java b/ebean-test/src/test/java/io/ebean/EbeanServer_refresh.java
similarity index 86%
rename from ebean-core/src/test/java/io/ebean/EbeanServer_refresh.java
rename to ebean-test/src/test/java/io/ebean/EbeanServer_refresh.java
index 66af5d164..86c25de9b 100644
--- a/ebean-core/src/test/java/io/ebean/EbeanServer_refresh.java
+++ b/ebean-test/src/test/java/io/ebean/EbeanServer_refresh.java
@@ -1,6 +1,6 @@
 package io.ebean;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
@@ -11,7 +11,7 @@ import java.util.HashMap;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class EbeanServer_refresh {
 
@@ -21,7 +21,7 @@ public class EbeanServer_refresh {
     Map<String, String> map = new HashMap<>();
     map.put("tableName", "e_basic");
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     DB.script().run("/scripts/test-script.sql");
     DB.script().run("/scripts/test-script-2.sql", map);
     server.script().run(this.getClass().getResource("/scripts/test-script.sql"));
@@ -40,10 +40,10 @@ public class EbeanServer_refresh {
     assertEquals(rows, 1);
 
     basic.setName("modify");
-    assertTrue(DB.getBeanState(basic).isDirty());
+    assertTrue(DB.beanState(basic).isDirty());
     server.refresh(basic);
     assertEquals(basic.getStatus(), EBasic.Status.ACTIVE);
-    assertFalse(DB.getBeanState(basic).isDirty());
+    assertFalse(DB.beanState(basic).isDirty());
   }
 
   @Test
@@ -51,11 +51,11 @@ public class EbeanServer_refresh {
 
     ResetBasicData.reset();
 
-    Order order = Ebean.find(Order.class, 1);
+    Order order = DB.find(Order.class, 1);
     order.getCustomer().getName();
     order.getDetails().size();
 
-    Ebean.refresh(order);
+    DB.refresh(order);
   }
 
   @Test
@@ -63,11 +63,11 @@ public class EbeanServer_refresh {
 
     ResetBasicData.reset();
 
-    Order order = Ebean.find(Order.class, 1);
+    Order order = DB.find(Order.class, 1);
     order.getCustomer().getName();
     order.setDetails(new ArrayList<>());
 
-    Ebean.refresh(order);
+    DB.refresh(order);
   }
 
   @Test
@@ -75,11 +75,11 @@ public class EbeanServer_refresh {
 
     ResetBasicData.reset();
 
-    Order order = Ebean.find(Order.class, 1);
+    Order order = DB.find(Order.class, 1);
     order.getCustomer().getName();
     order.setDetails(null);
 
-    Ebean.refresh(order);
+    DB.refresh(order);
   }
 
 
@@ -89,7 +89,7 @@ public class EbeanServer_refresh {
 
     ResetBasicData.reset();
 
-    Order order = Ebean.find(Order.class, 1);
+    Order order = DB.find(Order.class, 1);
 
     DB.refresh(order); // call refresh BEFORE first access on "getDetail";
 
@@ -123,7 +123,7 @@ public class EbeanServer_refresh {
 
     ResetBasicData.reset();
 
-    Order order = Ebean.find(Order.class, 1);
+    Order order = DB.find(Order.class, 1);
 
     DB.refresh(order); // call refresh BEFORE first access on "getDetail"
     // this changes the loader of the details-bean collection from DefaultServer to DLoadManyContext$LoadBuffer
diff --git a/ebean-core/src/test/java/io/ebean/EbeanServer_saveAllTest.java b/ebean-test/src/test/java/io/ebean/EbeanServer_saveAllTest.java
similarity index 73%
rename from ebean-core/src/test/java/io/ebean/EbeanServer_saveAllTest.java
rename to ebean-test/src/test/java/io/ebean/EbeanServer_saveAllTest.java
index 0187adcf1..474576b0c 100644
--- a/ebean-core/src/test/java/io/ebean/EbeanServer_saveAllTest.java
+++ b/ebean-test/src/test/java/io/ebean/EbeanServer_saveAllTest.java
@@ -1,10 +1,11 @@
 package io.ebean;
 
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -18,11 +19,11 @@ public class EbeanServer_saveAllTest extends BaseTestCase {
     List<EBasicVer> someBeans = beans(3);
 
     // act
-    LoggedSqlCollector.start();
-    Ebean.saveAll(someBeans);
+    LoggedSql.start();
+    DB.saveAll(someBeans);
 
     // assert
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(4);
     assertThat(loggedSql.get(0)).contains("insert into e_basicver (");
     assertThat(loggedSql.get(0)).contains("name, description, other, last_update) values (");
@@ -32,19 +33,19 @@ public class EbeanServer_saveAllTest extends BaseTestCase {
     }
 
     // act
-    LoggedSqlCollector.start();
-    Ebean.updateAll(someBeans);
+    LoggedSql.start();
+    DB.updateAll(someBeans);
 
-    loggedSql = LoggedSqlCollector.stop();
+    loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(3);
     assertThat(loggedSql.get(0)).contains("update e_basicver set name=?, last_update=? where id=? ");
 
     // act
-    LoggedSqlCollector.start();
-    Ebean.deleteAll(someBeans);
+    LoggedSql.start();
+    DB.deleteAll(someBeans);
 
-    loggedSql = LoggedSqlCollector.stop();
+    loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(4);
     assertThat(loggedSql.get(0)).contains("delete from e_basicver where id=?");
   }
@@ -52,74 +53,74 @@ public class EbeanServer_saveAllTest extends BaseTestCase {
   @Test
   public void saveAll_withExistingBatch_doesNotTriggerFlush() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     try (Transaction transaction = server.beginTransaction()) {
       transaction.setBatchMode(true);
-      LoggedSqlCollector.start();
+      LoggedSql.start();
 
       for (EBasicVer bean : beans(2)) {
         server.save(bean);
       }
 
       // jdbc batch, no sql yet
-      assertThat(LoggedSqlCollector.current()).isEmpty();
+      assertThat(LoggedSql.collect()).isEmpty();
 
       server.saveAll(beans(3));
 
       // still batch, no sql yet
-      assertThat(LoggedSqlCollector.current()).isEmpty();
+      assertThat(LoggedSql.collect()).isEmpty();
 
       for (EBasicVer bean : beans(2)) {
         server.save(bean);
       }
       // still batch, no sql yet
-      assertThat(LoggedSqlCollector.current()).isEmpty();
+      assertThat(LoggedSql.collect()).isEmpty();
 
       // flush now
       transaction.commit();
 
       // and we have our SQL from jdbc batch flush
-      assertThat(LoggedSqlCollector.stop()).isNotEmpty();
+      assertThat(LoggedSql.stop()).isNotEmpty();
     }
 
   }
 
   @Test
   public void deleteAll_withNull() {
-    Ebean.deleteAll(null);
+    DB.deleteAll(null);
   }
 
   @Test
   public void deleteAll_withEmpty() {
-    Ebean.saveAll(beans(0));
+    DB.saveAll(beans(0));
   }
 
   @Test
   public void saveAll_withNull() {
-    Ebean.saveAll(null);
+    DB.saveAll((Collection<?>)null);
   }
 
   @Test
   public void saveAll_withEmpty() {
-    Ebean.saveAll(beans(0));
+    DB.saveAll(beans(0));
   }
 
   @Test
   public void saveAll_withTransaction() {
 
     List<EBasicVer> someBeans = beans(3);
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     // act
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     try (Transaction txn = server.beginTransaction()) {
       server.saveAll(someBeans, txn);
       txn.commit();
     }
 
     // assert
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(4);
     assertThat(loggedSql.get(0)).contains("insert into e_basicver (");
     assertThat(loggedSql.get(0)).contains("name, description, other, last_update) values (");
@@ -129,23 +130,23 @@ public class EbeanServer_saveAllTest extends BaseTestCase {
     }
 
     // act
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     try (Transaction txn = server.beginTransaction()) {
       server.updateAll(someBeans, txn);
       txn.commit();
     }
-    loggedSql = LoggedSqlCollector.stop();
+    loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(3);
     assertThat(loggedSql.get(0)).contains("update e_basicver set name=?, last_update=? where id=? ");
 
     // act
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     try (Transaction txn = server.beginTransaction()) {
       server.deleteAll(someBeans, txn);
       txn.commit();
     }
-    loggedSql = LoggedSqlCollector.stop();
+    loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(4);
     assertThat(loggedSql.get(0)).contains("delete from e_basicver where id=?");
   }
diff --git a/ebean-core/src/test/java/io/ebean/ExtendedServerTest.java b/ebean-test/src/test/java/io/ebean/ExtendedServerTest.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebean/ExtendedServerTest.java
rename to ebean-test/src/test/java/io/ebean/ExtendedServerTest.java
index 5f756e9ad..9be28fa76 100644
--- a/ebean-core/src/test/java/io/ebean/ExtendedServerTest.java
+++ b/ebean-test/src/test/java/io/ebean/ExtendedServerTest.java
@@ -1,7 +1,7 @@
 package io.ebean;
 
-import org.junit.After;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -14,9 +14,9 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class ExtendedServerTest extends BaseTestCase {
 
-  @After
+  @AfterEach
   public void cleanup() {
-    Ebean.getDefaultServer()
+    DB.getDefault()
       .extended()
       .setClock(Clock.systemUTC());
   }
@@ -26,7 +26,7 @@ public class ExtendedServerTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     Query<Customer> query = server.find(Customer.class)
       .where().startsWith("name", "Rob")
@@ -52,7 +52,7 @@ public class ExtendedServerTest extends BaseTestCase {
   @Test
   public void mockClock() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     final Instant snapshot = Instant.now();
     Instant backedSnapshot = snapshot.minus(1, ChronoUnit.DAYS);
     Clock snapshotClock = Clock.fixed(backedSnapshot, Clock.systemUTC().getZone());
diff --git a/ebean-core/src/test/java/io/ebean/FetchConfigTest.java b/ebean-test/src/test/java/io/ebean/FetchConfigTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebean/FetchConfigTest.java
rename to ebean-test/src/test/java/io/ebean/FetchConfigTest.java
index f85808f6c..5c644b231 100644
--- a/ebean-core/src/test/java/io/ebean/FetchConfigTest.java
+++ b/ebean-test/src/test/java/io/ebean/FetchConfigTest.java
@@ -1,6 +1,6 @@
 package io.ebean;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/FetchGroupTest.java b/ebean-test/src/test/java/io/ebean/FetchGroupTest.java
similarity index 89%
rename from ebean-core/src/test/java/io/ebean/FetchGroupTest.java
rename to ebean-test/src/test/java/io/ebean/FetchGroupTest.java
index 9e3a88602..74744391e 100644
--- a/ebean-core/src/test/java/io/ebean/FetchGroupTest.java
+++ b/ebean-test/src/test/java/io/ebean/FetchGroupTest.java
@@ -1,8 +1,8 @@
 package io.ebean;
 
 import io.ebean.service.SpiFetchGroupQuery;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
@@ -47,10 +47,10 @@ public class FetchGroupTest extends BaseTestCase {
       .ilike("name", "rob")
       .select(fetch);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t0.status from o_customer");
     assertSql(sql.get(1)).contains("select t0.customer_id, t0.id, t0.first_name, t0.last_name, t0.email from contact");
@@ -75,10 +75,10 @@ public class FetchGroupTest extends BaseTestCase {
       .ilike("name", "rob")
       .select(fetch);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.id, t0.name from o_customer");
     assertSql(sql.get(1)).contains(" from contact");
@@ -105,10 +105,10 @@ public class FetchGroupTest extends BaseTestCase {
       .ilike("name", "rob")
       .select(FBCustomer);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t0.version, t1.id, t1.line_1, t1.line_2, t1.city, t2.code, t2.name from o_customer t0 left join o_address t1 on t1.id = t0.billing_address_id left join o_country t2 on t2.code = t1.country_code ");
   }
@@ -122,7 +122,7 @@ public class FetchGroupTest extends BaseTestCase {
 
     final FetchGroup<Customer> fetchGroup = query.buildFetchGroup();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Customer.find
       .query()
@@ -131,7 +131,7 @@ public class FetchGroupTest extends BaseTestCase {
       .select(fetchGroup)
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.id, t0.name from o_customer t0 where");
   }
diff --git a/ebean-core/src/test/java/io/ebean/MyCurrentUserProvider.java b/ebean-test/src/test/java/io/ebean/MyCurrentUserProvider.java
similarity index 100%
rename from ebean-core/src/test/java/io/ebean/MyCurrentUserProvider.java
rename to ebean-test/src/test/java/io/ebean/MyCurrentUserProvider.java
diff --git a/ebean-test/src/test/java/io/ebean/PlatformCondition.java b/ebean-test/src/test/java/io/ebean/PlatformCondition.java
new file mode 100644
index 000000000..9122bf826
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebean/PlatformCondition.java
@@ -0,0 +1,43 @@
+package io.ebean;
+
+import io.ebean.annotation.ForPlatform;
+import io.ebean.annotation.IgnorePlatform;
+import io.ebean.annotation.Platform;
+import org.junit.jupiter.api.extension.ConditionEvaluationResult;
+import org.junit.jupiter.api.extension.ExecutionCondition;
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+import java.lang.reflect.AnnotatedElement;
+import java.util.Optional;
+
+public class PlatformCondition implements ExecutionCondition {
+
+  private static final ConditionEvaluationResult ENABLED = ConditionEvaluationResult.enabled("ForPlatform is not present");
+
+  @Override
+  public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
+    Optional<AnnotatedElement> element = context.getElement();
+    if (element.isPresent()) {
+      final AnnotatedElement annotatedElement = element.get();
+      final ForPlatform annotation = annotatedElement.getAnnotation(ForPlatform.class);
+      if (annotation != null && !platformMath(annotation.value())) {
+        return ConditionEvaluationResult.disabled("@ForPlatform");
+      }
+      IgnorePlatform ignore = annotatedElement.getAnnotation(IgnorePlatform.class);
+      if (ignore != null && platformMath(ignore.value())) {
+        return ConditionEvaluationResult.disabled("@ForPlatform");
+      }
+    }
+    return ENABLED;
+  }
+
+  private boolean platformMath(Platform[] platforms) {
+    Platform basePlatform = DB.getDefault().platform().base();
+    for (Platform platform : platforms) {
+      if (platform.equals(basePlatform)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
diff --git a/ebean-core/src/test/java/io/ebean/PropertyTest.java b/ebean-test/src/test/java/io/ebean/PropertyTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebean/PropertyTest.java
rename to ebean-test/src/test/java/io/ebean/PropertyTest.java
index 77d22c439..128103dfb 100644
--- a/ebean-core/src/test/java/io/ebean/PropertyTest.java
+++ b/ebean-test/src/test/java/io/ebean/PropertyTest.java
@@ -1,10 +1,9 @@
 package io.ebean;
 
-import io.ebean.OrderBy;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 
 public class PropertyTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/SqlRowBooleanTest.java b/ebean-test/src/test/java/io/ebean/SqlRowBooleanTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebean/SqlRowBooleanTest.java
rename to ebean-test/src/test/java/io/ebean/SqlRowBooleanTest.java
index 1da2189eb..0c0b51522 100644
--- a/ebean-core/src/test/java/io/ebean/SqlRowBooleanTest.java
+++ b/ebean-test/src/test/java/io/ebean/SqlRowBooleanTest.java
@@ -1,6 +1,6 @@
 package io.ebean;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/StringHelperTest.java b/ebean-test/src/test/java/io/ebean/StringHelperTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebean/StringHelperTest.java
rename to ebean-test/src/test/java/io/ebean/StringHelperTest.java
index b4a5fabae..5beeeb905 100644
--- a/ebean-core/src/test/java/io/ebean/StringHelperTest.java
+++ b/ebean-test/src/test/java/io/ebean/StringHelperTest.java
@@ -1,15 +1,12 @@
 package io.ebean;
 
 import io.ebean.util.StringHelper;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class StringHelperTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/TestDirtyProperties.java b/ebean-test/src/test/java/io/ebean/TestDirtyProperties.java
similarity index 54%
rename from ebean-core/src/test/java/io/ebean/TestDirtyProperties.java
rename to ebean-test/src/test/java/io/ebean/TestDirtyProperties.java
index fabd51f38..3f2b0e581 100644
--- a/ebean-core/src/test/java/io/ebean/TestDirtyProperties.java
+++ b/ebean-test/src/test/java/io/ebean/TestDirtyProperties.java
@@ -3,14 +3,16 @@ package io.ebean;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
 import io.ebeaninternal.server.core.DefaultBeanState;
+import org.junit.jupiter.api.Test;
 import org.tests.model.embedded.EMain;
 import org.tests.model.embedded.Eembeddable;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.Map;
 import java.util.Set;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestDirtyProperties extends BaseTestCase {
 
   @Test
@@ -33,35 +35,33 @@ public class TestDirtyProperties extends BaseTestCase {
 
     DefaultBeanState beanState = new DefaultBeanState(eb);
 
-    Set<String> changedProps = beanState.getChangedProps();
-    Assert.assertEquals(1, changedProps.size());
-    Assert.assertTrue(changedProps.contains("name"));
+    Set<String> changedProps = beanState.changedProps();
+    assertEquals(1, changedProps.size());
+    assertThat(changedProps).contains("name");
 
-    Map<String, ValuePair> dirtyValues = beanState.getDirtyValues();
-    Assert.assertEquals(1, dirtyValues.size());
-    Assert.assertTrue(dirtyValues.keySet().contains("name"));
+    Map<String, ValuePair> dirtyValues = beanState.dirtyValues();
+    assertEquals(1, dirtyValues.size());
+    assertThat(dirtyValues.keySet()).contains("name");
 
     ValuePair valuePair = dirtyValues.get("name");
-    Assert.assertNotNull(valuePair);
-    Assert.assertEquals("changedFoo", valuePair.getNewValue());
-    Assert.assertEquals("foo", valuePair.getOldValue());
+    assertNotNull(valuePair);
+    assertEquals("changedFoo", valuePair.getNewValue());
+    assertEquals("foo", valuePair.getOldValue());
 
     Eembeddable embeddableRead = emain.getEmbeddable();
     embeddableRead.setDescription("embChanged");
 
-    Set<String> changedProps2 = beanState.getChangedProps();
-    Assert.assertEquals(2, changedProps2.size());
-    Assert.assertTrue(changedProps2.contains("name"));
-    Assert.assertTrue(changedProps2.contains("embeddable.description"));
+    Set<String> changedProps2 = beanState.changedProps();
+    assertEquals(2, changedProps2.size());
+    assertThat(changedProps2).contains("name", "embeddable.description");
 
-    Map<String, ValuePair> dirtyValues2 = beanState.getDirtyValues();
-    Assert.assertEquals(2, dirtyValues2.size());
-    Assert.assertTrue(dirtyValues2.keySet().contains("name"));
-    Assert.assertTrue(dirtyValues2.keySet().contains("embeddable.description"));
+    Map<String, ValuePair> dirtyValues2 = beanState.dirtyValues();
+    assertEquals(2, dirtyValues2.size());
+    assertThat(dirtyValues2.keySet()).contains("name", "embeddable.description");
 
     ValuePair valuePair2 = dirtyValues2.get("embeddable.description");
-    Assert.assertEquals("embChanged", valuePair2.getNewValue());
-    Assert.assertEquals("bar", valuePair2.getOldValue());
+    assertEquals("embChanged", valuePair2.getNewValue());
+    assertEquals("bar", valuePair2.getOldValue());
   }
 
 
@@ -83,31 +83,29 @@ public class TestDirtyProperties extends BaseTestCase {
 
     emain.setName("changedFoo");
 
-    Assert.assertSame(embeddable, emain.getEmbeddable());
+    assertSame(embeddable, emain.getEmbeddable());
 
     Eembeddable embeddable2 = setEmbeddedBean(emain, "changeEmbeddedInstance");
-    Assert.assertSame(embeddable2, emain.getEmbeddable());
-    Assert.assertNotSame(embeddable, emain.getEmbeddable());
+    assertSame(embeddable2, emain.getEmbeddable());
+    assertNotSame(embeddable, emain.getEmbeddable());
 
 
     DefaultBeanState beanState = new DefaultBeanState(eb);
 
-    Set<String> changedProps2 = beanState.getChangedProps();
-    Assert.assertEquals(2, changedProps2.size());
-    Assert.assertTrue(changedProps2.contains("name"));
+    Set<String> changedProps2 = beanState.changedProps();
+    assertEquals(2, changedProps2.size());
+    assertThat(changedProps2).contains("name");
 
-    Assert.assertTrue("The whole bean instance has changed", changedProps2.contains("embeddable"));
+    assertThat(changedProps2).contains("embeddable");
 
-    Map<String, ValuePair> dirtyValues2 = beanState.getDirtyValues();
-    Assert.assertEquals(2, dirtyValues2.size());
-    Assert.assertTrue(dirtyValues2.keySet().contains("name"));
-    Assert.assertTrue(dirtyValues2.keySet().contains("embeddable"));
+    Map<String, ValuePair> dirtyValues2 = beanState.dirtyValues();
+    assertEquals(2, dirtyValues2.size());
+    assertThat(dirtyValues2.keySet()).contains("name", "embeddable");
 
 
     ValuePair valuePair2 = dirtyValues2.get("embeddable");
-    Assert.assertSame(embeddable2, valuePair2.getNewValue());
-    Assert.assertSame(embeddable, valuePair2.getOldValue());
-
+    assertSame(embeddable2, valuePair2.getNewValue());
+    assertSame(embeddable, valuePair2.getOldValue());
   }
 
 
@@ -128,7 +126,7 @@ public class TestDirtyProperties extends BaseTestCase {
 
     // hooks the embeddable bean back to the owner
     int embeddablePropertyIndex = ebi.findProperty("embeddable");
-    Assert.assertTrue(embeddablePropertyIndex > -1);
+    assertThat(embeddablePropertyIndex).isGreaterThan(-1);
     ((EntityBean) embeddable)._ebean_getIntercept().setEmbeddedOwner(owner, embeddablePropertyIndex);
     return embeddable;
   }
diff --git a/ebean-core/src/test/java/io/ebean/TestFilterWithEnum.java b/ebean-test/src/test/java/io/ebean/TestFilterWithEnum.java
similarity index 60%
rename from ebean-core/src/test/java/io/ebean/TestFilterWithEnum.java
rename to ebean-test/src/test/java/io/ebean/TestFilterWithEnum.java
index c3805107f..dfe3b8932 100644
--- a/ebean-core/src/test/java/io/ebean/TestFilterWithEnum.java
+++ b/ebean-test/src/test/java/io/ebean/TestFilterWithEnum.java
@@ -1,12 +1,13 @@
 package io.ebean;
 
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestFilterWithEnum extends BaseTestCase {
 
   @Test
@@ -14,13 +15,12 @@ public class TestFilterWithEnum extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Order> allOrders = Ebean.find(Order.class).findList();
+    List<Order> allOrders = DB.find(Order.class).findList();
 
-    Filter<Order> filter = Ebean.filter(Order.class);
+    Filter<Order> filter = DB.filter(Order.class);
     List<Order> newOrders = filter.eq("status", Order.Status.NEW).filter(allOrders);
 
-    Assert.assertNotNull(newOrders);
-
+    assertNotNull(newOrders);
   }
 
 }
diff --git a/ebean-core/src/test/java/io/ebean/TestUnsetLoadedProperties.java b/ebean-test/src/test/java/io/ebean/TestUnsetLoadedProperties.java
similarity index 65%
rename from ebean-core/src/test/java/io/ebean/TestUnsetLoadedProperties.java
rename to ebean-test/src/test/java/io/ebean/TestUnsetLoadedProperties.java
index eb19d02d7..38d6cc22a 100644
--- a/ebean-core/src/test/java/io/ebean/TestUnsetLoadedProperties.java
+++ b/ebean-test/src/test/java/io/ebean/TestUnsetLoadedProperties.java
@@ -3,8 +3,8 @@ package io.ebean;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.bean.EntityBean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.converstation.User;
 
 import java.util.List;
@@ -30,17 +30,17 @@ public class TestUnsetLoadedProperties extends BaseTestCase {
     user.setEmail("change@junk.com");
 
 
-    BeanState beanState = Ebean.getBeanState(user);
-    assertThat(beanState.getLoadedProps()).containsExactly("id", "name", "email");
+    BeanState beanState = DB.beanState(user);
+    assertThat(beanState.loadedProps()).containsExactly("id", "name", "email");
 
     user.markPropertyUnset("email");
 
-    assertThat(beanState.getLoadedProps()).containsExactly("id", "name");
+    assertThat(beanState.loadedProps()).containsExactly("id", "name");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     user.update();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).doesNotContain("email");
   }
@@ -54,13 +54,13 @@ public class TestUnsetLoadedProperties extends BaseTestCase {
     user.setName("name mod");
     user.setEmail("change@junk.com");
 
-    BeanState beanState = Ebean.getBeanState(user);
-    assertThat(beanState.getLoadedProps()).containsExactly("id", "name", "email");
+    BeanState beanState = DB.beanState(user);
+    assertThat(beanState.loadedProps()).containsExactly("id", "name", "email");
 
     // unset the loaded state for email
     ((EntityBean) user)._ebean_getIntercept().setPropertyLoaded("email", false);
 
-    assertThat(beanState.getLoadedProps()).containsExactly("id", "name");
+    assertThat(beanState.loadedProps()).containsExactly("id", "name");
   }
 
   @Test
@@ -72,12 +72,12 @@ public class TestUnsetLoadedProperties extends BaseTestCase {
     user.setName("name mod");
     user.setEmail("change@junk.com");
 
-    BeanState beanState = Ebean.getBeanState(user);
-    assertThat(beanState.getLoadedProps()).containsExactly("id", "name", "email");
+    BeanState beanState = DB.beanState(user);
+    assertThat(beanState.loadedProps()).containsExactly("id", "name", "email");
 
 
     user.markPropertyUnset("email");
-    assertThat(beanState.getLoadedProps()).containsExactly("id", "name");
+    assertThat(beanState.loadedProps()).containsExactly("id", "name");
   }
 
   @Test
@@ -89,11 +89,11 @@ public class TestUnsetLoadedProperties extends BaseTestCase {
     user.setName("name mod");
     user.setEmail("change@junk.com");
 
-    BeanState beanState = Ebean.getBeanState(user);
-    assertThat(beanState.getLoadedProps()).containsExactly("id", "name", "email");
+    BeanState beanState = DB.beanState(user);
+    assertThat(beanState.loadedProps()).containsExactly("id", "name", "email");
 
-    Ebean.getBeanState(user).setPropertyLoaded("email", false);
-    assertThat(beanState.getLoadedProps()).containsExactly("id", "name");
+    DB.beanState(user).setPropertyLoaded("email", false);
+    assertThat(beanState.loadedProps()).containsExactly("id", "name");
   }
 
   /**
@@ -110,14 +110,14 @@ public class TestUnsetLoadedProperties extends BaseTestCase {
 
     newUser.save();
 
-    User updUser = Ebean.find(User.class, newUser.getId());
+    User updUser = DB.find(User.class, newUser.getId());
     updUser.setName("mod occ");
     updUser.markPropertyUnset("version");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     updUser.save();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("where id=?;");
   }
 }
diff --git a/ebean-core/src/test/java/io/ebean/TextExpressionListTest.java b/ebean-test/src/test/java/io/ebean/TextExpressionListTest.java
similarity index 85%
rename from ebean-core/src/test/java/io/ebean/TextExpressionListTest.java
rename to ebean-test/src/test/java/io/ebean/TextExpressionListTest.java
index 04d7d108c..e6c85b6f1 100644
--- a/ebean-core/src/test/java/io/ebean/TextExpressionListTest.java
+++ b/ebean-test/src/test/java/io/ebean/TextExpressionListTest.java
@@ -1,28 +1,27 @@
 package io.ebean;
 
 
-import io.ebean.Ebean;
 import io.ebean.search.Match;
 import io.ebean.search.MultiMatch;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
-import org.junit.Test;
 
 public class TextExpressionListTest {
 
   @Test
   public void syntax() {
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .text().match("name", "rob");
 
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .text().should()
       .match("name", "rob")
       .match("note", "war and peace");
 
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .text()
       .should()
       .match("title", "war and peace")
@@ -32,7 +31,7 @@ public class TextExpressionListTest {
       .match("translator", "Louise Maude");
 
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .text()
       .should()
       .match("title", "war and peace")
@@ -44,7 +43,7 @@ public class TextExpressionListTest {
       .gt("reviewDate", 12345);
 
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .text()
       .must()
       .match("title", "quick")
@@ -65,7 +64,7 @@ public class TextExpressionListTest {
   @Test
   public void syntax_multiMatch() {
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .text()
       .multiMatch("Will Smith", "title", "*name");
 
@@ -73,7 +72,7 @@ public class TextExpressionListTest {
       .opAnd()
       .type(MultiMatch.Type.PHRASE_PREFIX);
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .text()
       .multiMatch("Will Smith", match);
 
diff --git a/ebean-core/src/test/java/io/ebean/TransactionalTestCase.java b/ebean-test/src/test/java/io/ebean/TransactionalTestCase.java
similarity index 73%
rename from ebean-core/src/test/java/io/ebean/TransactionalTestCase.java
rename to ebean-test/src/test/java/io/ebean/TransactionalTestCase.java
index 3fcbb34bc..4975100fa 100644
--- a/ebean-core/src/test/java/io/ebean/TransactionalTestCase.java
+++ b/ebean-test/src/test/java/io/ebean/TransactionalTestCase.java
@@ -1,7 +1,7 @@
 package io.ebean;
 
-import org.junit.After;
-import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
 import org.tests.model.basic.ResetBasicData;
 
 /**
@@ -16,15 +16,15 @@ import org.tests.model.basic.ResetBasicData;
  */
 public abstract class TransactionalTestCase extends BaseTestCase {
 
-  @Before
+  @BeforeEach
   public void startTransaction() {
     ResetBasicData.reset();
-    Ebean.beginTransaction();
+    DB.beginTransaction();
   }
 
-  @After
+  @AfterEach
   public void endTransaction() {
-    Ebean.rollbackTransaction();
-    Ebean.endTransaction();
+    DB.rollbackTransaction();
+    DB.endTransaction();
   }
 }
diff --git a/ebean-core/src/test/java/io/ebean/TxScopeTest.java b/ebean-test/src/test/java/io/ebean/TxScopeTest.java
similarity index 90%
rename from ebean-core/src/test/java/io/ebean/TxScopeTest.java
rename to ebean-test/src/test/java/io/ebean/TxScopeTest.java
index 55524e4f0..6d6cb5ce9 100644
--- a/ebean-core/src/test/java/io/ebean/TxScopeTest.java
+++ b/ebean-test/src/test/java/io/ebean/TxScopeTest.java
@@ -1,10 +1,10 @@
 package io.ebean;
 
 import io.ebean.annotation.PersistBatch;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TxScopeTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/UpdateQueryTest.java b/ebean-test/src/test/java/io/ebean/UpdateQueryTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebean/UpdateQueryTest.java
rename to ebean-test/src/test/java/io/ebean/UpdateQueryTest.java
index 5b9c42991..26fcd0324 100644
--- a/ebean-core/src/test/java/io/ebean/UpdateQueryTest.java
+++ b/ebean-test/src/test/java/io/ebean/UpdateQueryTest.java
@@ -5,8 +5,8 @@ import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.meta.MetaQueryMetric;
 import io.ebean.meta.ServerMetrics;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasicWithUniqueCon;
@@ -16,6 +16,7 @@ import java.sql.Timestamp;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class UpdateQueryTest extends BaseTestCase {
 
@@ -24,7 +25,7 @@ public class UpdateQueryTest extends BaseTestCase {
 
     resetAllMetrics();
 
-    EbeanServer server = server();
+    Database server = server();
     UpdateQuery<Customer> update = server.update(Customer.class);
     Query<Customer> query = update
       .set("status", Customer.Status.ACTIVE)
@@ -54,7 +55,7 @@ public class UpdateQueryTest extends BaseTestCase {
 
     UpdateQuery<Customer> update = server().update(Customer.class);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     int rows = update
       .setRaw("status = status")
@@ -62,7 +63,7 @@ public class UpdateQueryTest extends BaseTestCase {
       .update();
 
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertThat(rows).isGreaterThan(0);
 
@@ -80,7 +81,7 @@ public class UpdateQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     int rows = server().find(Customer.class)
       .where()
@@ -91,7 +92,7 @@ public class UpdateQueryTest extends BaseTestCase {
       .update();
 
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertThat(rows).isEqualTo(0);
 
@@ -102,7 +103,7 @@ public class UpdateQueryTest extends BaseTestCase {
   public void query_asUpdate_idIn() {
 
     ResetBasicData.reset();
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     int rows = server().find(Customer.class)
       .where()
@@ -112,7 +113,7 @@ public class UpdateQueryTest extends BaseTestCase {
       .setLabel("asUpdateByIds")
       .update();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertThat(rows).isEqualTo(0);
 
@@ -126,7 +127,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void update_withTransactionBatch() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     try (Transaction transaction = server.beginTransaction()) {
       transaction.setBatchMode(true);
@@ -153,7 +154,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @IgnorePlatform(Platform.SQLSERVER)
   public void withTableAlias() {
 
-    EbeanServer server = server();
+    Database server = server();
     UpdateQuery<Customer> update = server.update(Customer.class);
     Query<Customer> query = update
       .set("status", Customer.Status.ACTIVE)
@@ -172,9 +173,9 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void withJoin() {
 
-    EbeanServer server = server();
+    Database server = server();
 
-    Country nz = server.getReference(Country.class, "NZ");
+    Country nz = server.reference(Country.class, "NZ");
 
     UpdateQuery<Customer> update = server.update(Customer.class);
     Query<Customer> query = update
@@ -196,11 +197,11 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void withJoinAndLimit() {
 
-    EbeanServer server = server();
+    Database server = server();
 
-    Country nz = server.getReference(Country.class, "NZ");
+    Country nz = server.reference(Country.class, "NZ");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     server.update(Customer.class)
       .set("status", Customer.Status.ACTIVE)
@@ -210,7 +211,7 @@ public class UpdateQueryTest extends BaseTestCase {
       .setMaxRows(100)
       .update();
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("update o_customer set status=?  where id in (select t0.id from o_customer t0 left join o_address t1 on t1.id = t0.billing_address_id where t1.country_code = ? and t0.id > ? limit 100)");
   }
 
@@ -218,9 +219,9 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void simpleWithLimit() {
 
-    EbeanServer server = server();
+    Database server = server();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     server.update(Customer.class)
       .set("status", Customer.Status.ACTIVE)
@@ -229,7 +230,7 @@ public class UpdateQueryTest extends BaseTestCase {
       .setMaxRows(100)
       .update();
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     if (isMySql() || isH2() || isMariaDB()) {
       assertSql(sql.get(0)).contains("update o_customer set status=? where id > ? limit 100");
     } else {
@@ -240,7 +241,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void whereIsEmpty() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     Query<Customer> updateQuery = server
       .update(Customer.class)
@@ -258,7 +259,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void setNull() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     Query<Customer> updateQuery = server
       .update(Customer.class)
@@ -275,7 +276,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void set_whenValueIsNull_expectNull() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     Query<Customer> updateQuery = server
       .update(Customer.class)
@@ -292,7 +293,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void setExpression() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     Query<Customer> updateQuery = server
       .update(Customer.class)
@@ -309,7 +310,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void setExpression_withBind() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     Query<Customer> updateQuery = server
       .update(Customer.class)
@@ -326,7 +327,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void fluidSyntax() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     int rows = server
       .update(Customer.class)
@@ -341,7 +342,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void updateQuery_withExplicitTransaction() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     int rowsExprList;
     int rowsQuery;
@@ -373,7 +374,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void deleteQuery_withExplicitTransaction() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     int rowsExprList;
     int rowsQuery;
@@ -402,7 +403,7 @@ public class UpdateQueryTest extends BaseTestCase {
   @Test
   public void useViaEbean() {
 
-    int rows = Ebean.update(Customer.class)
+    int rows = DB.update(Customer.class)
       .setRaw("status = coalesce(status, ?)", Customer.Status.ACTIVE)
       .where()
       .gt("id", 10000)
@@ -411,17 +412,18 @@ public class UpdateQueryTest extends BaseTestCase {
     assertThat(rows).isEqualTo(0);
   }
 
-  @Test(expected = DuplicateKeyException.class)
+  @Test
   public void exceptionTranslation() {
-
     newEbasicWithUnique("o1","other1_a");
     Integer id = newEbasicWithUnique("o2", "other1_b");
 
-    Ebean.update(EBasicWithUniqueCon.class)
-      .set("other", "other1_a")
-      .set("otherOne", "other1_a")
-      .where().idEq(id)
-      .update();
+    assertThrows(DuplicateKeyException.class, () -> {
+      DB.update(EBasicWithUniqueCon.class)
+        .set("other", "other1_a")
+        .set("otherOne", "other1_a")
+        .where().idEq(id)
+        .update();
+    });
   }
 
   private Integer newEbasicWithUnique(String name, String other) {
@@ -429,7 +431,7 @@ public class UpdateQueryTest extends BaseTestCase {
     b0.setName(name);
     b0.setOther(other);
     b0.setOtherOne(other);
-    Ebean.save(b0);
+    DB.save(b0);
 
     return b0.getId();
   }
diff --git a/ebean-core/src/test/java/io/ebean/annotation/ForPlatform.java b/ebean-test/src/test/java/io/ebean/annotation/ForPlatform.java
similarity index 100%
rename from ebean-core/src/test/java/io/ebean/annotation/ForPlatform.java
rename to ebean-test/src/test/java/io/ebean/annotation/ForPlatform.java
diff --git a/ebean-core/src/test/java/io/ebean/annotation/IgnorePlatform.java b/ebean-test/src/test/java/io/ebean/annotation/IgnorePlatform.java
similarity index 100%
rename from ebean-core/src/test/java/io/ebean/annotation/IgnorePlatform.java
rename to ebean-test/src/test/java/io/ebean/annotation/IgnorePlatform.java
diff --git a/ebean-core/src/test/java/io/ebean/bean/EntityBeanInterceptTest.java b/ebean-test/src/test/java/io/ebean/bean/EntityBeanInterceptTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebean/bean/EntityBeanInterceptTest.java
rename to ebean-test/src/test/java/io/ebean/bean/EntityBeanInterceptTest.java
index 31891de2f..e233bc562 100644
--- a/ebean-core/src/test/java/io/ebean/bean/EntityBeanInterceptTest.java
+++ b/ebean-test/src/test/java/io/ebean/bean/EntityBeanInterceptTest.java
@@ -2,11 +2,11 @@ package io.ebean.bean;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.compositekeys.db.AuditInfo;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasic;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.sql.Date;
 import java.util.HashSet;
@@ -14,8 +14,8 @@ import java.util.List;
 import java.util.Set;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class EntityBeanInterceptTest extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/io/ebean/cache/CacheKeyTest.java b/ebean-test/src/test/java/io/ebean/cache/CacheKeyTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebean/cache/CacheKeyTest.java
rename to ebean-test/src/test/java/io/ebean/cache/CacheKeyTest.java
index 98225a6e6..4e0b987f9 100644
--- a/ebean-core/src/test/java/io/ebean/cache/CacheKeyTest.java
+++ b/ebean-test/src/test/java/io/ebean/cache/CacheKeyTest.java
@@ -1,6 +1,6 @@
 package io.ebean.cache;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-test/src/test/java/io/ebean/cache/ServerCacheManagerTest.java b/ebean-test/src/test/java/io/ebean/cache/ServerCacheManagerTest.java
new file mode 100644
index 000000000..9145f46ab
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebean/cache/ServerCacheManagerTest.java
@@ -0,0 +1,48 @@
+package io.ebean.cache;
+
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class ServerCacheManagerTest {
+
+  @Test
+  public void test() {
+
+    ServerCacheManager cacheManager = DB.getDefault().cacheManager();
+
+    for (ServerCacheRegion region : cacheManager.allRegions()) {
+      assertTrue(region.isEnabled());
+    }
+
+    cacheManager.enabledRegions("r0,doesNotExist");
+    assertThat(cacheManager.region("email").isEnabled()).isFalse();
+    assertThat(cacheManager.region("r0").isEnabled()).isTrue();
+
+    cacheManager.enabledRegions("r0");
+    assertThat(cacheManager.region("email").isEnabled()).isFalse();
+    assertThat(cacheManager.region("r0").isEnabled()).isTrue();
+
+    cacheManager.enabledRegions(null);
+    assertThat(cacheManager.region("email").isEnabled()).isFalse();
+    assertThat(cacheManager.region("r0").isEnabled()).isTrue();
+
+    cacheManager.enabledRegions("email");
+    assertThat(cacheManager.region("email").isEnabled()).isTrue();
+    assertThat(cacheManager.region("r0").isEnabled()).isFalse();
+
+    cacheManager.allRegionsEnabled(false);
+    for (ServerCacheRegion region : cacheManager.allRegions()) {
+      assertFalse(region.isEnabled());
+    }
+
+    cacheManager.allRegionsEnabled(true);
+    for (ServerCacheRegion region : cacheManager.allRegions()) {
+      assertTrue(region.isEnabled());
+    }
+
+  }
+}
diff --git a/ebean-core/src/test/java/io/ebean/cache/ServerCacheOptionsTest.java b/ebean-test/src/test/java/io/ebean/cache/ServerCacheOptionsTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebean/cache/ServerCacheOptionsTest.java
rename to ebean-test/src/test/java/io/ebean/cache/ServerCacheOptionsTest.java
index 47f569c74..4601a321d 100644
--- a/ebean-core/src/test/java/io/ebean/cache/ServerCacheOptionsTest.java
+++ b/ebean-test/src/test/java/io/ebean/cache/ServerCacheOptionsTest.java
@@ -1,6 +1,6 @@
 package io.ebean.cache;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/common/BeanListTest.java b/ebean-test/src/test/java/io/ebean/common/BeanListTest.java
similarity index 99%
rename from ebean-core/src/test/java/io/ebean/common/BeanListTest.java
rename to ebean-test/src/test/java/io/ebean/common/BeanListTest.java
index 03c08efad..fc041549e 100644
--- a/ebean-core/src/test/java/io/ebean/common/BeanListTest.java
+++ b/ebean-test/src/test/java/io/ebean/common/BeanListTest.java
@@ -1,7 +1,7 @@
 package io.ebean.common;
 
 import io.ebean.bean.BeanCollection;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Comparator;
diff --git a/ebean-core/src/test/java/io/ebean/common/BeanMapTest.java b/ebean-test/src/test/java/io/ebean/common/BeanMapTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebean/common/BeanMapTest.java
rename to ebean-test/src/test/java/io/ebean/common/BeanMapTest.java
index 3101fc0f2..fc9a481cd 100644
--- a/ebean-core/src/test/java/io/ebean/common/BeanMapTest.java
+++ b/ebean-test/src/test/java/io/ebean/common/BeanMapTest.java
@@ -1,13 +1,14 @@
 package io.ebean.common;
 
 import io.ebean.bean.BeanCollection;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
 
 import java.util.*;
 
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 
 public class BeanMapTest {
@@ -189,33 +190,32 @@ public class BeanMapTest {
     assertThat(map.getModifyAdditions()).isEmpty();
   }
 
-  @Test(expected = UnsupportedOperationException.class)
+  @Test
   public void keySet_add_whenModifyListening() {
     BeanMap<String, EBasic> map = newModifyListeningMap();
-    map.keySet().add("3");
+    assertThrows(UnsupportedOperationException.class, () -> map.keySet().add("3"));
   }
 
-  @Test(expected = UnsupportedOperationException.class)
+  @Test
   public void keySet_add() {
     BeanMap<String, Object> map = new BeanMap<>();
-    map.keySet().add("3");
+    assertThrows(UnsupportedOperationException.class, () ->map.keySet().add("3"));
   }
 
-  @Test(expected = UnsupportedOperationException.class)
+  @Test
   public void keySet_addAll_whenModifyListening() {
     BeanMap<String, EBasic> map = newModifyListeningMap();
-    map.keySet().addAll(asList("3", "4"));
+    assertThrows(UnsupportedOperationException.class, () -> map.keySet().addAll(asList("3", "4")));
   }
 
-  @Test(expected = UnsupportedOperationException.class)
+  @Test
   public void keySet_addAll() {
     BeanMap<String, Object> map = new BeanMap<>();
-    map.keySet().addAll(asList("3", "4"));
+    assertThrows(UnsupportedOperationException.class, () -> map.keySet().addAll(asList("3", "4")));
   }
 
   @Test
   public void keySet_remove() {
-
     BeanMap<String, Object> map = new BeanMap<>();
     map.put("1", object1);
     map.put("2", object2);
@@ -233,7 +233,6 @@ public class BeanMapTest {
 
   @Test
   public void keySet_clear() {
-
     BeanMap<String, Object> map = new BeanMap<>();
     map.put("1", object1);
     map.put("2", object2);
@@ -315,23 +314,24 @@ public class BeanMapTest {
     assertThat(map.getModifyRemovals()).containsOnly(object1, object4);
   }
 
-  @Test(expected = UnsupportedOperationException.class)
+  @Test
   public void values_add() {
     BeanMap<String, EBasic> map = new BeanMap<>();
-    map.values().add(object3);
+    assertThrows(UnsupportedOperationException.class, () -> map.values().add(object3));
   }
 
-  @Test(expected = UnsupportedOperationException.class)
+  @Test
   public void values_addAll() {
     BeanMap<String, EBasic> map = new BeanMap<>();
-    map.values().addAll(asList(object3, object5));
+    assertThrows(UnsupportedOperationException.class, () -> map.values().addAll(asList(object3, object5)));
   }
 
-  @Test(expected = UnsupportedOperationException.class)
+  @Test
   public void entrySet_add() {
-    newModifyListeningMap()
+    assertThrows(UnsupportedOperationException.class, () ->
+      newModifyListeningMap()
       .entrySet()
-      .add(new AbstractMap.SimpleEntry<>("3", object3));
+      .add(new AbstractMap.SimpleEntry<>("3", object3)));
   }
 
   @Test
diff --git a/ebean-core/src/test/java/io/ebean/common/BeanSetTest.java b/ebean-test/src/test/java/io/ebean/common/BeanSetTest.java
similarity index 99%
rename from ebean-core/src/test/java/io/ebean/common/BeanSetTest.java
rename to ebean-test/src/test/java/io/ebean/common/BeanSetTest.java
index 40253faef..7bc12bb07 100644
--- a/ebean-core/src/test/java/io/ebean/common/BeanSetTest.java
+++ b/ebean-test/src/test/java/io/ebean/common/BeanSetTest.java
@@ -1,7 +1,7 @@
 package io.ebean.common;
 
 import io.ebean.bean.BeanCollection;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.LinkedHashSet;
 import java.util.Set;
diff --git a/ebean-core/src/test/java/io/ebean/config/ContainerConfigTest.java b/ebean-test/src/test/java/io/ebean/config/ContainerConfigTest.java
similarity index 89%
rename from ebean-core/src/test/java/io/ebean/config/ContainerConfigTest.java
rename to ebean-test/src/test/java/io/ebean/config/ContainerConfigTest.java
index 23c4d0b6c..183360a07 100644
--- a/ebean-core/src/test/java/io/ebean/config/ContainerConfigTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/ContainerConfigTest.java
@@ -1,10 +1,10 @@
 package io.ebean.config;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Properties;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ContainerConfigTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/config/DatabaseConfigTest.java b/ebean-test/src/test/java/io/ebean/config/DatabaseConfigTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebean/config/DatabaseConfigTest.java
rename to ebean-test/src/test/java/io/ebean/config/DatabaseConfigTest.java
index 368bc9a8f..143e3b19e 100644
--- a/ebean-core/src/test/java/io/ebean/config/DatabaseConfigTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/DatabaseConfigTest.java
@@ -5,15 +5,12 @@ import io.ebean.annotation.MutationDetection;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.config.dbplatform.IdType;
 import io.ebean.datasource.DataSourceConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Properties;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class DatabaseConfigTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/config/DbConstraintNamingTest.java b/ebean-test/src/test/java/io/ebean/config/DbConstraintNamingTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebean/config/DbConstraintNamingTest.java
rename to ebean-test/src/test/java/io/ebean/config/DbConstraintNamingTest.java
index ca5dbb13f..9153b2f74 100644
--- a/ebean-core/src/test/java/io/ebean/config/DbConstraintNamingTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/DbConstraintNamingTest.java
@@ -1,6 +1,6 @@
 package io.ebean.config;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/DbMigrationConfigTest.java b/ebean-test/src/test/java/io/ebean/config/DbMigrationConfigTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebean/config/DbMigrationConfigTest.java
rename to ebean-test/src/test/java/io/ebean/config/DbMigrationConfigTest.java
index 80f3e7c64..03465543b 100644
--- a/ebean-core/src/test/java/io/ebean/config/DbMigrationConfigTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/DbMigrationConfigTest.java
@@ -1,11 +1,12 @@
 package io.ebean.config;
 
-import org.junit.Test;
+import io.ebean.migration.MigrationConfig;
+import org.junit.jupiter.api.Test;
 
 import java.util.Properties;
-import io.ebean.migration.MigrationConfig;
+
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 
 public class DbMigrationConfigTest {
diff --git a/ebean-core/src/test/java/io/ebean/config/DocStoreConfigTest.java b/ebean-test/src/test/java/io/ebean/config/DocStoreConfigTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebean/config/DocStoreConfigTest.java
rename to ebean-test/src/test/java/io/ebean/config/DocStoreConfigTest.java
index 8919fab4a..a497e0d92 100644
--- a/ebean-core/src/test/java/io/ebean/config/DocStoreConfigTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/DocStoreConfigTest.java
@@ -1,13 +1,11 @@
 package io.ebean.config;
 
 import io.ebean.annotation.DocStoreMode;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Properties;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class DocStoreConfigTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/config/MatchingNamingConventionTest.java b/ebean-test/src/test/java/io/ebean/config/MatchingNamingConventionTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebean/config/MatchingNamingConventionTest.java
rename to ebean-test/src/test/java/io/ebean/config/MatchingNamingConventionTest.java
index 2db6b95ba..d832f1370 100644
--- a/ebean-core/src/test/java/io/ebean/config/MatchingNamingConventionTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/MatchingNamingConventionTest.java
@@ -2,12 +2,12 @@ package io.ebean.config;
 
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebean.config.dbplatform.sqlserver.SqlServer17Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class MatchingNamingConventionTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/config/PlatformNoGeneratedKeysTest.java b/ebean-test/src/test/java/io/ebean/config/PlatformNoGeneratedKeysTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebean/config/PlatformNoGeneratedKeysTest.java
rename to ebean-test/src/test/java/io/ebean/config/PlatformNoGeneratedKeysTest.java
index c363be10f..9d600fc56 100644
--- a/ebean-core/src/test/java/io/ebean/config/PlatformNoGeneratedKeysTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/PlatformNoGeneratedKeysTest.java
@@ -7,8 +7,8 @@ import io.ebean.annotation.Platform;
 import io.ebean.config.dbplatform.DbIdentity;
 import io.ebean.config.dbplatform.IdType;
 import io.ebean.config.dbplatform.h2.H2Platform;
-import org.junit.AfterClass;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 import org.tests.model.draftable.BasicDraftableBean;
 
@@ -18,7 +18,7 @@ public class PlatformNoGeneratedKeysTest {
 
   static Database server = testH2Server();
 
-  @AfterClass
+  @AfterAll
   public static void shutdown() {
     server.shutdown();
   }
diff --git a/ebean-core/src/test/java/io/ebean/config/PropertiesWrapperTest.java b/ebean-test/src/test/java/io/ebean/config/PropertiesWrapperTest.java
similarity index 89%
rename from ebean-core/src/test/java/io/ebean/config/PropertiesWrapperTest.java
rename to ebean-test/src/test/java/io/ebean/config/PropertiesWrapperTest.java
index 2954f1f9d..98a64ad0b 100644
--- a/ebean-core/src/test/java/io/ebean/config/PropertiesWrapperTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/PropertiesWrapperTest.java
@@ -2,12 +2,12 @@ package io.ebean.config;
 
 import io.avaje.config.Config;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Properties;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class PropertiesWrapperTest {
 
@@ -66,14 +66,14 @@ public class PropertiesWrapperTest {
     assertEquals(42, pw.getInt("someInt", 99));
     assertEquals(Double.valueOf(5.5D), (Double.valueOf(pw.getDouble("someDouble", 99.9D))));
     assertEquals(home + "/hello", pw.get("somePath", null));
-    assertEquals(tmpDir, "/aaa/" + tmpDir + "/bbb", pw.get("someSystemProp"));
+    assertEquals("/aaa/" + tmpDir + "/bbb", pw.get("someSystemProp"));
 
     pw = new PropertiesWrapper(evalCopy, null);
 
     assertEquals(42, pw.getInt("someInt", 99));
     assertEquals(Double.valueOf(5.5D), (Double.valueOf(pw.getDouble("someDouble", 99.9D))));
     assertEquals(home + "/hello", pw.get("somePath", null));
-    assertEquals(tmpDir, "/aaa/" + tmpDir + "/bbb", pw.get("someSystemProp"));
+    assertEquals("/aaa/" + tmpDir + "/bbb", pw.get("someSystemProp"));
   }
 
 }
diff --git a/ebean-core/src/test/java/io/ebean/config/ServerConfigSqlServerTest.java b/ebean-test/src/test/java/io/ebean/config/ServerConfigSqlServerTest.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebean/config/ServerConfigSqlServerTest.java
rename to ebean-test/src/test/java/io/ebean/config/ServerConfigSqlServerTest.java
index 4a4dd820d..4f3449df4 100644
--- a/ebean-core/src/test/java/io/ebean/config/ServerConfigSqlServerTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/ServerConfigSqlServerTest.java
@@ -5,20 +5,19 @@ import io.ebean.Database;
 import io.ebean.DatabaseFactory;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 
-import javax.persistence.PersistenceException;
 import java.util.Properties;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class ServerConfigSqlServerTest {
 
-  @Ignore
+  @Disabled
   @ForPlatform({Platform.SQLSERVER})
-  @Test(expected = PersistenceException.class)
+  @Test //expected = PersistenceException.class
   public void need_explicitPlatform() {
 
     Properties props = props("some_sqlserver");
@@ -43,7 +42,7 @@ public class ServerConfigSqlServerTest {
     assertThat(sqlServer).isNotNull();
     sqlServer.shutdown();
 
-//    javax.persistence.PersistenceException: java.lang.IllegalArgumentException: For SqlServer please choose the more specific sqlserver16 or sqlserver17 platform via ServerConfig.setDatabasePlatformName. Refer to issue #1340 for details
+//    javax.persistence.PersistenceException: java.lang.IllegalArgumentException: For SqlServer please choose the more specific sqlserver16 or sqlserver17 platform via DatabaseConfig.setDatabasePlatformName. Refer to issue #1340 for details
 //
 //    at io.ebeaninternal.server.core.DatabasePlatformFactory.create(DatabasePlatformFactory.java:62)
 //    at io.ebeaninternal.server.core.DefaultContainer.setDatabasePlatform(DefaultContainer.java:266)
@@ -51,11 +50,10 @@ public class ServerConfigSqlServerTest {
 //    at io.ebeaninternal.server.core.DefaultContainer.createServer(DefaultContainer.java:45)
 //    at io.ebean.EbeanServerFactory.createInternal(EbeanServerFactory.java:109)
 //    at io.ebean.EbeanServerFactory.create(EbeanServerFactory.java:70)
-//    at io.ebean.config.ServerConfigSqlServerTest.need_explicitPlatform(ServerConfigSqlServerTest.java:35)
 
   }
 
-  @Ignore
+  @Disabled
   @ForPlatform({Platform.SQLSERVER})
   @Test
   public void explicit_17() {
@@ -86,7 +84,7 @@ public class ServerConfigSqlServerTest {
     sqlServer.shutdown();
   }
 
-  @Ignore
+  @Disabled
   @ForPlatform({Platform.SQLSERVER})
   @Test
   public void explicit_16() {
diff --git a/ebean-core/src/test/java/org/tests/config/TestTableName.java b/ebean-test/src/test/java/io/ebean/config/TestTableName.java
similarity index 61%
rename from ebean-core/src/test/java/org/tests/config/TestTableName.java
rename to ebean-test/src/test/java/io/ebean/config/TestTableName.java
index 83fefa08b..ccf73ce03 100644
--- a/ebean-core/src/test/java/org/tests/config/TestTableName.java
+++ b/ebean-test/src/test/java/io/ebean/config/TestTableName.java
@@ -1,11 +1,11 @@
-package org.tests.config;
+package io.ebean.config;
 
 import io.ebean.BaseTestCase;
-import io.ebean.config.TableName;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestTableName extends BaseTestCase {
 
@@ -31,26 +31,26 @@ public class TestTableName extends BaseTestCase {
   public void test() {
 
     TableName t = new TableName("a");
-    Assert.assertEquals("a", t.getName());
-    Assert.assertNull(t.getCatalog());
-    Assert.assertNull(t.getSchema());
+    assertEquals("a", t.getName());
+    assertNull(t.getCatalog());
+    assertNull(t.getSchema());
 
     t = new TableName("b.a");
-    Assert.assertEquals("a", t.getName());
-    Assert.assertEquals("b", t.getSchema());
-    Assert.assertNull(t.getCatalog());
+    assertEquals("a", t.getName());
+    assertEquals("b", t.getSchema());
+    assertNull(t.getCatalog());
 
     t = new TableName("c.b.a");
-    Assert.assertEquals("a", t.getName());
-    Assert.assertEquals("b", t.getSchema());
-    Assert.assertEquals("c", t.getCatalog());
+    assertEquals("a", t.getName());
+    assertEquals("b", t.getSchema());
+    assertEquals("c", t.getCatalog());
 
 //		try {
 //			TableName t2 = new TableName("d.c.b.a");
-//			Assert.assertNotNull(t2);
-//			Assert.assertTrue(false);
+//			assertNotNull(t2);
+//			assertTrue(false);
 //		} catch (RuntimeException e){
-//			Assert.assertTrue(true);
+//			assertTrue(true);
 //		}
 
 
@@ -60,8 +60,8 @@ public class TestTableName extends BaseTestCase {
 //		UnderscoreNamingConvention nc = new UnderscoreNamingConvention();
 //		TableName intTab = nc.getM2MJoinTableName(lhs, rhs);
 //
-//		Assert.assertNull(intTab.getCatalog());
-//		Assert.assertEquals("test", intTab.getSchema());
-//		Assert.assertEquals("oe_order_cust", intTab.getName());
+//		assertNull(intTab.getCatalog());
+//		assertEquals("test", intTab.getSchema());
+//		assertEquals("oe_order_cust", intTab.getName());
   }
 }
diff --git a/ebean-core/src/test/java/io/ebean/config/UnderscoreNamingConventionTest.java b/ebean-test/src/test/java/io/ebean/config/UnderscoreNamingConventionTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebean/config/UnderscoreNamingConventionTest.java
rename to ebean-test/src/test/java/io/ebean/config/UnderscoreNamingConventionTest.java
index a1574ebed..b117d47ae 100644
--- a/ebean-core/src/test/java/io/ebean/config/UnderscoreNamingConventionTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/UnderscoreNamingConventionTest.java
@@ -1,6 +1,6 @@
 package io.ebean.config;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/BasicSqlLimitOffsetTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/BasicSqlLimitOffsetTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/BasicSqlLimitOffsetTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/BasicSqlLimitOffsetTest.java
index d4fb59cd9..f10469d52 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/BasicSqlLimitOffsetTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/BasicSqlLimitOffsetTest.java
@@ -1,6 +1,6 @@
 package io.ebean.config.dbplatform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/BasicSqlStandardLimiterTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/BasicSqlStandardLimiterTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/BasicSqlStandardLimiterTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/BasicSqlStandardLimiterTest.java
index 25f479643..3e8da3acc 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/BasicSqlStandardLimiterTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/BasicSqlStandardLimiterTest.java
@@ -1,6 +1,6 @@
 package io.ebean.config.dbplatform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/DatabasePlatformTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/DatabasePlatformTest.java
similarity index 77%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/DatabasePlatformTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/DatabasePlatformTest.java
index 40d8b6e28..5569064ba 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/DatabasePlatformTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/DatabasePlatformTest.java
@@ -4,84 +4,83 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.config.MatchingNamingConvention;
 import io.ebean.config.PlatformConfig;
-import io.ebean.config.ServerConfig;
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
 import io.ebean.config.dbplatform.sqlserver.SqlServer17Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DatabasePlatformTest extends BaseTestCase {
 
   @Test
   @ForPlatform(Platform.H2)
   public void h2_platform() {
-    final Platform platform = DB.getDefault().getPlatform();
+    final Platform platform = DB.getDefault().platform();
     assertThat(platform).isSameAs(Platform.H2);
   }
 
   @Test
   @ForPlatform(Platform.POSTGRES)
   public void postgres_platform() {
-    final Platform platform = DB.getDefault().getPlatform().base();
+    final Platform platform = DB.getDefault().platform().base();
     assertThat(platform).isSameAs(Platform.POSTGRES);
   }
 
   @Test
   @ForPlatform(Platform.MYSQL)
   public void mysql_platform() {
-    final Platform platform = DB.getDefault().getPlatform().base();
+    final Platform platform = DB.getDefault().platform().base();
     assertThat(platform).isSameAs(Platform.MYSQL);
   }
 
   @Test
   @ForPlatform(Platform.MARIADB)
   public void mariadb_platform() {
-    final Platform platform = DB.getDefault().getPlatform().base();
+    final Platform platform = DB.getDefault().platform().base();
     assertThat(platform).isSameAs(Platform.MARIADB);
   }
 
   @Test
   @ForPlatform(Platform.SQLSERVER)
   public void sqlserver_platform() {
-    final Platform platform = DB.getDefault().getPlatform().base();
+    final Platform platform = DB.getDefault().platform().base();
     assertThat(platform).isSameAs(Platform.SQLSERVER);
   }
 
   @Test
   public void convertQuotedIdentifiers_when_allQuotedIdentifier_sqlServer() {
 
-    ServerConfig config = new ServerConfig();
+    DatabaseConfig config = new DatabaseConfig();
     config.setAllQuotedIdentifiers(true);
     config.setNamingConvention(new MatchingNamingConvention());
 
     DatabasePlatform dbPlatform = new SqlServer17Platform();
     dbPlatform.configure(config.getPlatformConfig(), config.isAllQuotedIdentifiers());
 
-    assertEquals(dbPlatform.convertQuotedIdentifiers("order"),"[order]");
-    assertEquals(dbPlatform.convertQuotedIdentifiers("`order`"),"[order]");
-    assertEquals(dbPlatform.convertQuotedIdentifiers("firstName"),"[firstName]");
+    assertEquals(dbPlatform.convertQuotedIdentifiers("order"), "[order]");
+    assertEquals(dbPlatform.convertQuotedIdentifiers("`order`"), "[order]");
+    assertEquals(dbPlatform.convertQuotedIdentifiers("firstName"), "[firstName]");
   }
 
   @Test
   public void convertQuotedIdentifiers() {
-
-    ServerConfig config = new ServerConfig();
+    DatabaseConfig config = new DatabaseConfig();
 
     DatabasePlatform dbPlatform = new SqlServer17Platform();
     dbPlatform.configure(config.getPlatformConfig(), config.isAllQuotedIdentifiers());
 
-    assertEquals(dbPlatform.convertQuotedIdentifiers("order"),"order");
-    assertEquals(dbPlatform.convertQuotedIdentifiers("`order`"),"[order]");
-    assertEquals(dbPlatform.convertQuotedIdentifiers("firstName"),"firstName");
+    assertEquals(dbPlatform.convertQuotedIdentifiers("order"), "order");
+    assertEquals(dbPlatform.convertQuotedIdentifiers("`order`"), "[order]");
+    assertEquals(dbPlatform.convertQuotedIdentifiers("firstName"), "firstName");
 
-    assertEquals(dbPlatform.unQuote("order"),"order");
-    assertEquals(dbPlatform.unQuote("[order]"),"order");
-    assertEquals(dbPlatform.unQuote("[firstName]"),"firstName");
+    assertEquals(dbPlatform.unQuote("order"), "order");
+    assertEquals(dbPlatform.unQuote("[order]"), "order");
+    assertEquals(dbPlatform.unQuote("[firstName]"), "firstName");
   }
 
   @Test
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/DbIdentityTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/DbIdentityTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/DbIdentityTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/DbIdentityTest.java
index ad97776b4..52b23173a 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/DbIdentityTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/DbIdentityTest.java
@@ -1,9 +1,9 @@
 package io.ebean.config.dbplatform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class DbIdentityTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeLookupTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeLookupTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeLookupTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeLookupTest.java
index 5d71bc7e0..f53b5baf0 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeLookupTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeLookupTest.java
@@ -1,10 +1,10 @@
 package io.ebean.config.dbplatform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Types;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DbPlatformTypeLookupTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeMappingTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeMappingTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeMappingTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeMappingTest.java
index 0f1307446..27fbaf159 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeMappingTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeMappingTest.java
@@ -1,6 +1,6 @@
 package io.ebean.config.dbplatform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Types;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeParserTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeParserTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeParserTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeParserTest.java
index cf964d033..44f85c2ac 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeParserTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/DbPlatformTypeParserTest.java
@@ -1,8 +1,8 @@
 package io.ebean.config.dbplatform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DbPlatformTypeParserTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/DbTypeMapTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/DbTypeMapTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/DbTypeMapTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/DbTypeMapTest.java
index 7ea2e5e20..e85f6ea15 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/DbTypeMapTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/DbTypeMapTest.java
@@ -1,7 +1,7 @@
 package io.ebean.config.dbplatform;
 
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/HanaHistorySupportTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/HanaHistorySupportTest.java
similarity index 87%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/HanaHistorySupportTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/HanaHistorySupportTest.java
index 9af554f9e..cec87e885 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/HanaHistorySupportTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/HanaHistorySupportTest.java
@@ -1,10 +1,10 @@
 package io.ebean.config.dbplatform;
 
 import io.ebean.config.dbplatform.hana.HanaHistorySupport;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class HanaHistorySupportTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/HanaPlatformTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/HanaPlatformTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/HanaPlatformTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/HanaPlatformTest.java
index 1c7600861..94ff431c7 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/HanaPlatformTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/HanaPlatformTest.java
@@ -2,7 +2,7 @@ package io.ebean.config.dbplatform;
 
 import io.ebean.config.PlatformConfig;
 import io.ebean.config.dbplatform.hana.HanaPlatform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/MySqlHistorySupportTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/MySqlHistorySupportTest.java
similarity index 89%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/MySqlHistorySupportTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/MySqlHistorySupportTest.java
index e6413305e..9993f5450 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/MySqlHistorySupportTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/MySqlHistorySupportTest.java
@@ -2,9 +2,9 @@ package io.ebean.config.dbplatform;
 
 
 import io.ebean.config.dbplatform.mysql.MySqlHistorySupport;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class MySqlHistorySupportTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/MySqlPlatformTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/MySqlPlatformTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/MySqlPlatformTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/MySqlPlatformTest.java
index 676566e85..450749f96 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/MySqlPlatformTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/MySqlPlatformTest.java
@@ -2,7 +2,7 @@ package io.ebean.config.dbplatform;
 
 import io.ebean.config.PlatformConfig;
 import io.ebean.config.dbplatform.mysql.MySqlPlatform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/OraclePlatformTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/OraclePlatformTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/OraclePlatformTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/OraclePlatformTest.java
index 15e9dda00..cf6b513ee 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/OraclePlatformTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/OraclePlatformTest.java
@@ -3,7 +3,7 @@ package io.ebean.config.dbplatform;
 import io.ebean.config.PlatformConfig;
 import io.ebean.config.dbplatform.oracle.Oracle11Platform;
 import io.ebean.config.dbplatform.oracle.OraclePlatform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/PostgresHistorySupportTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/PostgresHistorySupportTest.java
similarity index 90%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/PostgresHistorySupportTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/PostgresHistorySupportTest.java
index 2c851cbdc..6dcb81431 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/PostgresHistorySupportTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/PostgresHistorySupportTest.java
@@ -1,9 +1,9 @@
 package io.ebean.config.dbplatform;
 
 import io.ebean.config.dbplatform.postgres.PostgresHistorySupport;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class PostgresHistorySupportTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/PostgresPlatformTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/PostgresPlatformTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/PostgresPlatformTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/PostgresPlatformTest.java
index 6ed8c3e88..b7b6d524f 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/PostgresPlatformTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/PostgresPlatformTest.java
@@ -3,7 +3,7 @@ package io.ebean.config.dbplatform;
 import io.ebean.Query;
 import io.ebean.config.PlatformConfig;
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/SequenceBatchIdGeneratorTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/SequenceBatchIdGeneratorTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/SequenceBatchIdGeneratorTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/SequenceBatchIdGeneratorTest.java
index 7969c8778..295096e75 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/SequenceBatchIdGeneratorTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/SequenceBatchIdGeneratorTest.java
@@ -1,6 +1,6 @@
 package io.ebean.config.dbplatform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.ResultSet;
 import java.util.List;
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/SqlserverPlatformTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/SqlserverPlatformTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/SqlserverPlatformTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/SqlserverPlatformTest.java
index 306032f50..887b19a3d 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/SqlserverPlatformTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/SqlserverPlatformTest.java
@@ -2,7 +2,7 @@ package io.ebean.config.dbplatform;
 
 import io.ebean.config.PlatformConfig;
 import io.ebean.config.dbplatform.sqlserver.SqlServer17Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServer2016PlatformTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServer2016PlatformTest.java
similarity index 78%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServer2016PlatformTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServer2016PlatformTest.java
index 092adcebe..9740f6858 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServer2016PlatformTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServer2016PlatformTest.java
@@ -1,8 +1,8 @@
 package io.ebean.config.dbplatform.sqlserver;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * @author Vilmos Nagy  <vilmos.nagy@outlook.com>
diff --git a/ebean-core/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServerStepSequenceTest.java b/ebean-test/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServerStepSequenceTest.java
similarity index 86%
rename from ebean-core/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServerStepSequenceTest.java
rename to ebean-test/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServerStepSequenceTest.java
index 6c356021b..1ca441253 100644
--- a/ebean-core/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServerStepSequenceTest.java
+++ b/ebean-test/src/test/java/io/ebean/config/dbplatform/sqlserver/SqlServerStepSequenceTest.java
@@ -4,8 +4,8 @@ import io.ebean.BackgroundExecutor;
 import io.ebean.BaseTestCase;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -17,7 +17,7 @@ public class SqlServerStepSequenceTest extends BaseTestCase {
 
   private static final Logger log = LoggerFactory.getLogger(SqlServerStepSequenceTest.class);
 
-  @Ignore
+  @Disabled
   @ForPlatform(Platform.SQLSERVER)
   @Test
   public void seq() {
@@ -26,8 +26,8 @@ public class SqlServerStepSequenceTest extends BaseTestCase {
     server().sqlUpdate("drop sequence if exists sqls_testseq_9876").execute();
     server().sqlUpdate("create sequence sqls_testseq_9876 start with 1 increment by 50").execute();
 
-    BackgroundExecutor be = server().getBackgroundExecutor();
-    DataSource ds = server().getDataSource();
+    BackgroundExecutor be = server().backgroundExecutor();
+    DataSource ds = server().dataSource();
 
     SqlServerStepSequence s = new SqlServerStepSequence(be, ds, "sqls_testseq_9876", 50);
 
diff --git a/ebean-core/src/test/java/io/ebean/event/BeanFindControllerTest.java b/ebean-test/src/test/java/io/ebean/event/BeanFindControllerTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebean/event/BeanFindControllerTest.java
rename to ebean-test/src/test/java/io/ebean/event/BeanFindControllerTest.java
index 6b2468478..4d8b5ee88 100644
--- a/ebean-core/src/test/java/io/ebean/event/BeanFindControllerTest.java
+++ b/ebean-test/src/test/java/io/ebean/event/BeanFindControllerTest.java
@@ -6,17 +6,14 @@ import io.ebean.DatabaseFactory;
 import io.ebean.bean.BeanCollection;
 import io.ebean.common.BeanList;
 import io.ebean.config.DatabaseConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.example.ModUuidGenerator;
 import org.tests.model.basic.EBasic;
 import org.tests.model.basic.ECustomId;
 
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class BeanFindControllerTest extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/io/ebean/event/BeanPersistControllerTest.java b/ebean-test/src/test/java/io/ebean/event/BeanPersistControllerTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebean/event/BeanPersistControllerTest.java
rename to ebean-test/src/test/java/io/ebean/event/BeanPersistControllerTest.java
index 2d2625067..e42088df2 100644
--- a/ebean-core/src/test/java/io/ebean/event/BeanPersistControllerTest.java
+++ b/ebean-test/src/test/java/io/ebean/event/BeanPersistControllerTest.java
@@ -5,7 +5,7 @@ import io.ebean.Database;
 import io.ebean.DatabaseFactory;
 import io.ebean.Transaction;
 import io.ebean.config.DatabaseConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 import org.tests.model.basic.UTDetail;
 import org.tests.model.basic.UTMaster;
@@ -168,7 +168,7 @@ public class BeanPersistControllerTest {
     public boolean preUpdate(BeanPersistRequest<?> request) {
       methodsCalled.add("preUpdate");
 
-      Object bean = request.getBean();
+      Object bean = request.bean();
       if (bean instanceof UTDetail) {
         UTDetail detail = (UTDetail)bean;
         // invoke lazy loading ... which invoke the flush of the jdbc batch
diff --git a/ebean-core/src/test/java/io/ebean/event/BeanPostLoadTest.java b/ebean-test/src/test/java/io/ebean/event/BeanPostLoadTest.java
similarity index 86%
rename from ebean-core/src/test/java/io/ebean/event/BeanPostLoadTest.java
rename to ebean-test/src/test/java/io/ebean/event/BeanPostLoadTest.java
index 4b0dcde41..87cab8635 100644
--- a/ebean-core/src/test/java/io/ebean/event/BeanPostLoadTest.java
+++ b/ebean-test/src/test/java/io/ebean/event/BeanPostLoadTest.java
@@ -1,13 +1,9 @@
 package io.ebean.event;
 
 
-import io.ebean.BaseTestCase;
-import io.ebean.BeanState;
-import io.ebean.DB;
-import io.ebean.Database;
-import io.ebean.DatabaseFactory;
+import io.ebean.*;
 import io.ebean.config.DatabaseConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 
 import java.util.ArrayList;
@@ -37,7 +33,7 @@ public class BeanPostLoadTest extends BaseTestCase {
 
     assertThat(postLoad.methodsCalled).hasSize(1);
     assertThat(postLoad.methodsCalled).containsExactly("postLoad");
-    assertThat(postLoad.beanState.getLoadedProps()).containsExactly("id", "name", "other");
+    assertThat(postLoad.beanState.loadedProps()).containsExactly("id", "name", "other");
     assertThat(postLoad.bean).isSameAs(found);
 
     db.delete(bean);
@@ -91,7 +87,7 @@ public class BeanPostLoadTest extends BaseTestCase {
     public void postLoad(Object bean) {
       this.methodsCalled.add("postLoad");
       this.bean = bean;
-      this.beanState = DB.getBeanState(bean);
+      this.beanState = DB.beanState(bean);
     }
 
   }
diff --git a/ebean-core/src/test/java/io/ebean/event/readaudit/ReadAuditQueryPlanTest.java b/ebean-test/src/test/java/io/ebean/event/readaudit/ReadAuditQueryPlanTest.java
similarity index 79%
rename from ebean-core/src/test/java/io/ebean/event/readaudit/ReadAuditQueryPlanTest.java
rename to ebean-test/src/test/java/io/ebean/event/readaudit/ReadAuditQueryPlanTest.java
index bcb3fac30..d29d4a432 100644
--- a/ebean-core/src/test/java/io/ebean/event/readaudit/ReadAuditQueryPlanTest.java
+++ b/ebean-test/src/test/java/io/ebean/event/readaudit/ReadAuditQueryPlanTest.java
@@ -1,10 +1,10 @@
 package io.ebean.event.readaudit;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 
 public class ReadAuditQueryPlanTest {
 
diff --git a/ebean-core/src/test/java/io/ebean/json/EJsonTests.java b/ebean-test/src/test/java/io/ebean/json/EJsonTests.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebean/json/EJsonTests.java
rename to ebean-test/src/test/java/io/ebean/json/EJsonTests.java
index 770aa8378..929c6582c 100644
--- a/ebean-core/src/test/java/io/ebean/json/EJsonTests.java
+++ b/ebean-test/src/test/java/io/ebean/json/EJsonTests.java
@@ -1,11 +1,11 @@
 package io.ebean.json;
 
-import io.ebean.text.json.EJson;
-import io.ebeaninternal.json.ModifyAwareMap;
-import io.ebean.ModifyAwareType;
 import com.fasterxml.jackson.core.JsonFactory;
 import com.fasterxml.jackson.core.JsonParser;
-import org.junit.Test;
+import io.ebean.ModifyAwareType;
+import io.ebean.text.json.EJson;
+import io.ebeaninternal.json.ModifyAwareMap;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -14,14 +14,9 @@ import java.io.FileWriter;
 import java.io.IOException;
 import java.io.StringReader;
 import java.nio.file.Files;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class EJsonTests {
 
diff --git a/ebean-core/src/test/java/io/ebean/plugin/BeanTypeTest.java b/ebean-test/src/test/java/io/ebean/plugin/BeanTypeTest.java
similarity index 56%
rename from ebean-core/src/test/java/io/ebean/plugin/BeanTypeTest.java
rename to ebean-test/src/test/java/io/ebean/plugin/BeanTypeTest.java
index 820e89408..cb6e4a9d2 100644
--- a/ebean-core/src/test/java/io/ebean/plugin/BeanTypeTest.java
+++ b/ebean-test/src/test/java/io/ebean/plugin/BeanTypeTest.java
@@ -7,20 +7,12 @@ import io.ebean.Query;
 import io.ebean.text.PathProperties;
 import io.ebeaninternal.api.SpiQuery;
 import io.ebeaninternal.server.querydefn.OrmQueryDetail;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.inheritance.Stockforecast;
-import org.tests.model.basic.Car;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.OrderDetail;
-import org.tests.model.basic.Person;
-import org.tests.model.basic.Product;
-import org.tests.model.basic.Vehicle;
+import org.tests.model.basic.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 
 public class BeanTypeTest {
@@ -28,44 +20,42 @@ public class BeanTypeTest {
   private static Database db = DB.getDefault();
 
   private <T> BeanType<T> beanType(Class<T> cls) {
-    return db.getPluginApi().getBeanType(cls);
+    return db.pluginApi().beanType(cls);
   }
 
   @Test
   public void getBeanType() {
-    assertThat(beanType(Order.class).getBeanType()).isEqualTo(Order.class);
+    assertThat(beanType(Order.class).type()).isEqualTo(Order.class);
   }
 
   @Test
   public void getTypeAtPath_when_ManyToOne() {
     BeanType<Order> orderType = beanType(Order.class);
-    BeanType<?> customerType = orderType.getBeanTypeAtPath("customer");
-    assertThat(customerType.getBeanType()).isEqualTo(Customer.class);
+    BeanType<?> customerType = orderType.beanTypeAtPath("customer");
+    assertThat(customerType.type()).isEqualTo(Customer.class);
   }
 
   @Test
   public void getTypeAtPath_when_OneToMany() {
     BeanType<Order> orderType = beanType(Order.class);
-    BeanType<?> detailsType = orderType.getBeanTypeAtPath("details");
-    assertThat(detailsType.getBeanType()).isEqualTo(OrderDetail.class);
+    BeanType<?> detailsType = orderType.beanTypeAtPath("details");
+    assertThat(detailsType.type()).isEqualTo(OrderDetail.class);
   }
 
   @Test
   public void getTypeAtPath_when_nested() {
     BeanType<Order> orderType = beanType(Order.class);
-    BeanType<?> productType = orderType.getBeanTypeAtPath("details.product");
-    assertThat(productType.getBeanType()).isEqualTo(Product.class);
+    BeanType<?> productType = orderType.beanTypeAtPath("details.product");
+    assertThat(productType.type()).isEqualTo(Product.class);
   }
 
-  @Test(expected = RuntimeException.class)
+  @Test
   public void getTypeAtPath_when_simpleType() {
-
-    beanType(Order.class).getBeanTypeAtPath("status");
+    assertThrows(RuntimeException.class, () -> beanType(Order.class).beanTypeAtPath("status"));
   }
 
   @Test
   public void createBean() {
-
     assertThat(beanType(Order.class).createBean()).isNotNull();
   }
 
@@ -74,15 +64,15 @@ public class BeanTypeTest {
 
     Order order = new Order();
     order.setStatus(Order.Status.APPROVED);
-    Property statusProperty = beanType(Order.class).getProperty("status");
+    Property statusProperty = beanType(Order.class).property("status");
 
-    assertThat(statusProperty.getVal(order)).isEqualTo(order.getStatus());
+    assertThat(statusProperty.value(order)).isEqualTo(order.getStatus());
   }
 
   @Test
   public void getBaseTable() {
 
-    assertThat(beanType(Order.class).getBaseTable()).isEqualTo("o_order");
+    assertThat(beanType(Order.class).baseTable()).isEqualTo("o_order");
   }
 
   @Test
@@ -91,18 +81,15 @@ public class BeanTypeTest {
     Order order = new Order();
     order.setId(42);
 
-    Object id1 = beanType(Order.class).beanId(order);
-    Object id2 = beanType(Order.class).getBeanId(order);
-
+    Object id1 = beanType(Order.class).id(order);
     assertThat(id1).isEqualTo(order.getId());
-    assertThat(id2).isEqualTo(order.getId());
   }
 
   @Test
   public void setBeanId() {
 
     Order order = new Order();
-    beanType(Order.class).setBeanId(order, 42);
+    beanType(Order.class).setId(order, 42);
 
     assertThat(42).isEqualTo(order.getId());
   }
@@ -113,15 +100,15 @@ public class BeanTypeTest {
     assertThat(beanType(Order.class).isDocStoreMapped()).isFalse();
     assertThat(beanType(Person.class).isDocStoreMapped()).isFalse();
 
-    assertThat(beanType(Order.class).getDocMapping()).isNotNull();
-    assertThat(beanType(Person.class).getDocMapping()).isNull();
+    assertThat(beanType(Order.class).docMapping()).isNotNull();
+    assertThat(beanType(Person.class).docMapping()).isNull();
   }
 
   @Test
   public void docStore_getEmbedded() {
 
     BeanDocType<Order> orderDocType = beanType(Order.class).docStore();
-    FetchPath customer = orderDocType.getEmbedded("customer");
+    FetchPath customer = orderDocType.embedded("customer");
     assertThat(customer).isNotNull();
     assertThat(customer.getProperties(null)).contains("id", "name");
   }
@@ -131,10 +118,10 @@ public class BeanTypeTest {
 
     BeanDocType<Order> orderDocType = beanType(Order.class).docStore();
 
-    FetchPath detailsPath = orderDocType.getEmbedded("details");
+    FetchPath detailsPath = orderDocType.embedded("details");
     assertThat(detailsPath).isNotNull();
 
-    FetchPath detailsRoot = orderDocType.getEmbeddedManyRoot("details");
+    FetchPath detailsRoot = orderDocType.embeddedManyRoot("details");
     assertThat(detailsRoot).isNotNull();
     assertThat(detailsRoot.getProperties(null)).containsExactly("id", "details");
     assertThat(detailsRoot.hasPath("details")).isTrue();
@@ -143,22 +130,22 @@ public class BeanTypeTest {
   @Test
   public void getDocStoreQueueId() {
 
-    assertThat(beanType(Order.class).getDocStoreQueueId()).isEqualTo("order");
-    assertThat(beanType(Customer.class).getDocStoreQueueId()).isEqualTo("customer");
+    assertThat(beanType(Order.class).docStoreQueueId()).isEqualTo("order");
+    assertThat(beanType(Customer.class).docStoreQueueId()).isEqualTo("customer");
   }
 
   @Test
   public void getDocStoreIndexType() {
 
-    assertThat(beanType(Order.class).docStore().getIndexType()).isEqualTo("order");
-    assertThat(beanType(Customer.class).docStore().getIndexType()).isEqualTo("customer");
+    assertThat(beanType(Order.class).docStore().indexType()).isEqualTo("order");
+    assertThat(beanType(Customer.class).docStore().indexType()).isEqualTo("customer");
   }
 
   @Test
   public void getDocStoreIndexName() {
 
-    assertThat(beanType(Order.class).docStore().getIndexType()).isEqualTo("order");
-    assertThat(beanType(Customer.class).docStore().getIndexType()).isEqualTo("customer");
+    assertThat(beanType(Order.class).docStore().indexType()).isEqualTo("order");
+    assertThat(beanType(Customer.class).docStore().indexType()).isEqualTo("customer");
   }
 
   @Test
@@ -166,7 +153,7 @@ public class BeanTypeTest {
 
     FetchPath parse = PathProperties.parse("id,name");
 
-    FetchPath nestedCustomer = beanType(Order.class).docStore().getEmbedded("customer");
+    FetchPath nestedCustomer = beanType(Order.class).docStore().embedded("customer");
     assertThat(nestedCustomer.toString()).isEqualTo(parse.toString());
   }
 
@@ -180,19 +167,19 @@ public class BeanTypeTest {
     assertThat(detail.getChunk("customer", false).getIncluded()).containsExactly("id", "name");
   }
 
-  @Test(expected = IllegalStateException.class)
-  public void docStoreIndex() throws Exception {
-    beanType(Order.class).docStore().index(1, new Order(), null);
+  @Test
+  public void docStoreIndex() {
+    assertThrows(IllegalStateException.class, () -> beanType(Order.class).docStore().index(1, new Order(), null));
   }
 
-  @Test(expected = IllegalStateException.class)
-  public void docStoreDeleteById() throws Exception {
-    beanType(Order.class).docStore().deleteById(1, null);
+  @Test
+  public void docStoreDeleteById() {
+    assertThrows(IllegalStateException.class, () -> beanType(Order.class).docStore().deleteById(1, null));
   }
 
-  @Test(expected = IllegalStateException.class)
-  public void docStoreUpdateEmbedded() throws Exception {
-    beanType(Order.class).docStore().updateEmbedded(1, "customer", "someJson", null);
+  @Test
+  public void docStoreUpdateEmbedded() {
+    assertThrows(IllegalStateException.class, () -> beanType(Order.class).docStore().updateEmbedded(1, "customer", "someJson", null));
   }
 
   @Test
@@ -212,12 +199,12 @@ public class BeanTypeTest {
 
   @Test
   public void getDiscColumn_when_default() {
-    assertEquals(beanType(Car.class).getDiscColumn(), "dtype");
+    assertEquals(beanType(Car.class).discColumn(), "dtype");
   }
 
   @Test
   public void getDiscColumn_when_set() {
-    assertEquals(beanType(Stockforecast.class).getDiscColumn(), "type");
+    assertEquals(beanType(Stockforecast.class).discColumn(), "type");
   }
 
   @Test
diff --git a/ebean-core/src/test/java/io/ebean/plugin/ExpressionPathTest.java b/ebean-test/src/test/java/io/ebean/plugin/ExpressionPathTest.java
similarity index 72%
rename from ebean-core/src/test/java/io/ebean/plugin/ExpressionPathTest.java
rename to ebean-test/src/test/java/io/ebean/plugin/ExpressionPathTest.java
index 274cbb846..4bf5d1f0e 100644
--- a/ebean-core/src/test/java/io/ebean/plugin/ExpressionPathTest.java
+++ b/ebean-test/src/test/java/io/ebean/plugin/ExpressionPathTest.java
@@ -1,8 +1,8 @@
 package io.ebean.plugin;
 
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
@@ -12,52 +12,52 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class ExpressionPathTest {
 
-  static EbeanServer server = Ebean.getDefaultServer();
+  static Database server = DB.getDefault();
 
   <T> BeanType<T> beanType(Class<T> cls) {
-    return server.getPluginApi().getBeanType(cls);
+    return server.pluginApi().beanType(cls);
   }
 
   @Test
   public void containsMany_when_many() throws Exception {
 
     BeanType<Order> beanType = beanType(Order.class);
-    assertThat(beanType.getExpressionPath("details").containsMany()).isTrue();
+    assertThat(beanType.expressionPath("details").containsMany()).isTrue();
   }
 
   @Test
   public void containsMany_when_manyChild() throws Exception {
 
     BeanType<Order> beanType = beanType(Order.class);
-    assertThat(beanType.getExpressionPath("details.id").containsMany()).isTrue();
+    assertThat(beanType.expressionPath("details.id").containsMany()).isTrue();
   }
 
   @Test
   public void containsMany_when_manyGrandChild() throws Exception {
 
     BeanType<Order> beanType = beanType(Order.class);
-    assertThat(beanType.getExpressionPath("details.product.sku").containsMany()).isTrue();
+    assertThat(beanType.expressionPath("details.product.sku").containsMany()).isTrue();
   }
 
   @Test
   public void containsMany_when_one() throws Exception {
 
     BeanType<Order> beanType = beanType(Order.class);
-    assertThat(beanType.getExpressionPath("customer.name").containsMany()).isFalse();
+    assertThat(beanType.expressionPath("customer.name").containsMany()).isFalse();
   }
 
   @Test
   public void containsMany_when_oneWithMany() throws Exception {
 
     BeanType<Order> beanType = beanType(Order.class);
-    assertThat(beanType.getExpressionPath("customer.contacts").containsMany()).isTrue();
+    assertThat(beanType.expressionPath("customer.contacts").containsMany()).isTrue();
   }
 
   @Test
   public void containsMany_when_oneWithManyChild() throws Exception {
 
     BeanType<Order> beanType = beanType(Order.class);
-    assertThat(beanType.getExpressionPath("customer.contacts.firstName").containsMany()).isTrue();
+    assertThat(beanType.expressionPath("customer.contacts.firstName").containsMany()).isTrue();
   }
 
   @Test
@@ -65,7 +65,7 @@ public class ExpressionPathTest {
 
     BeanType<Order> beanType = beanType(Order.class);
     Order order = new Order();
-    beanType.getExpressionPath("id").pathSet(order, 42);
+    beanType.expressionPath("id").pathSet(order, 42);
     assertThat(order.getId()).isEqualTo(42);
   }
 
@@ -74,7 +74,7 @@ public class ExpressionPathTest {
 
     BeanType<Order> beanType = beanType(Order.class);
     Order order = new Order();
-    beanType.getExpressionPath("customer.name").pathSet(order, "Rob");
+    beanType.expressionPath("customer.name").pathSet(order, "Rob");
     assertThat(order.getCustomer().getName()).isEqualTo("Rob");
   }
 
@@ -94,7 +94,7 @@ public class ExpressionPathTest {
     customer = server.find(Customer.class, customer.getId());
     assertThat(customer.getName()).isEqualTo("foo");
 
-    customerBeanType.getExpressionPath("name").pathSet(customer, "bar");
+    customerBeanType.expressionPath("name").pathSet(customer, "bar");
     server.save(customer);
 
     customer = server.find(Customer.class, customer.getId());
@@ -108,7 +108,7 @@ public class ExpressionPathTest {
 
     order = server.find(Order.class, order.getId());
 
-    ExpressionPath customerNamePath = orderBeanType.getExpressionPath("customer.name");
+    ExpressionPath customerNamePath = orderBeanType.expressionPath("customer.name");
     assertThat(customerNamePath.pathGet(order)).isEqualTo("bar");
 
     customerNamePath.pathSet(order, "baz");
diff --git a/ebean-test/src/test/java/io/ebean/plugin/PropertyTest.java b/ebean-test/src/test/java/io/ebean/plugin/PropertyTest.java
new file mode 100644
index 000000000..d20757d55
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebean/plugin/PropertyTest.java
@@ -0,0 +1,56 @@
+package io.ebean.plugin;
+
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ */
+public class PropertyTest {
+
+  static Database server = DB.getDefault();
+
+  <T> BeanType<T> beanType(Class<T> cls) {
+    return server.pluginApi().beanType(cls);
+  }
+
+  @Test
+  public void getVal() throws Exception {
+
+    Customer customer = new Customer();
+
+    Order order = new Order();
+    order.setCustomer(customer);
+    order.setStatus(Order.Status.APPROVED);
+
+    Property statusProperty = beanType(Order.class).property("status");
+    assertThat(statusProperty.value(order)).isEqualTo(order.getStatus());
+
+    Property customerProperty = beanType(Order.class).property("customer");
+    assertThat(customerProperty.value(order)).isEqualTo(customer);
+  }
+
+  @Test
+  public void isMany_when_not() {
+
+    assertThat(beanType(Order.class).property("status").isMany()).isFalse();
+    assertThat(beanType(Order.class).property("customer").isMany()).isFalse();
+  }
+
+  @Test
+  public void isMany_when_true() {
+
+    assertThat(beanType(Order.class).property("details").isMany()).isTrue();
+  }
+
+  @Test
+  public void name() {
+    assertThat(beanType(Order.class).property("status").name()).isEqualTo("status");
+    assertThat(beanType(Order.class).property("customer").name()).isEqualTo("customer");
+    assertThat(beanType(Order.class).property("details").name()).isEqualTo("details");
+  }
+}
diff --git a/ebean-test/src/test/java/io/ebean/plugin/SpiServerTest.java b/ebean-test/src/test/java/io/ebean/plugin/SpiServerTest.java
new file mode 100644
index 000000000..2189aaa44
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebean/plugin/SpiServerTest.java
@@ -0,0 +1,56 @@
+package io.ebean.plugin;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.VwCustomer;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+
+public class SpiServerTest extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Database defaultServer = DB.getDefault();
+    SpiServer pluginApi = defaultServer.pluginApi();
+
+    BeanType<Customer> beanType = pluginApi.beanType(Customer.class);
+    assertEquals("o_customer", beanType.baseTable());
+    assertNotNull(pluginApi.databasePlatform());
+    assertNull(beanType.findController());
+    assertNotNull(beanType.persistController());
+    assertNull(beanType.persistListener());
+    assertNull(beanType.queryAdapter());
+
+    assertTrue(beanType.isValidExpression("name"));
+    assertTrue(beanType.isValidExpression("contacts.firstName"));
+    assertTrue(beanType.isValidExpression("contacts.group.name"));
+    assertFalse(beanType.isValidExpression("junk"));
+    assertFalse(beanType.isValidExpression("Name"));
+    assertFalse(beanType.isValidExpression("contacts.name"));
+
+    Customer customer = new Customer();
+    customer.setId(42);
+
+    assertEquals(42, beanType.id(customer));
+
+    List<? extends BeanType<?>> beanTypes = pluginApi.beanTypes("o_customer");
+    assertEquals(2, beanTypes.size());
+
+    BeanType<VwCustomer> vwBeanType = pluginApi.beanType(VwCustomer.class);
+
+    assertThat(beanTypes.contains(beanType)).isTrue();
+    assertThat(beanTypes.contains(vwBeanType)).isTrue();
+
+    List<? extends BeanType<?>> allTypes = pluginApi.beanTypes();
+    assertFalse(allTypes.isEmpty());
+  }
+
+}
diff --git a/ebean-core/src/test/java/io/ebean/server/type/MyDayOfWeek.java b/ebean-test/src/test/java/io/ebean/server/type/MyDayOfWeek.java
similarity index 100%
rename from ebean-core/src/test/java/io/ebean/server/type/MyDayOfWeek.java
rename to ebean-test/src/test/java/io/ebean/server/type/MyDayOfWeek.java
diff --git a/ebean-core/src/test/java/io/ebean/server/type/MyEnum.java b/ebean-test/src/test/java/io/ebean/server/type/MyEnum.java
similarity index 100%
rename from ebean-core/src/test/java/io/ebean/server/type/MyEnum.java
rename to ebean-test/src/test/java/io/ebean/server/type/MyEnum.java
diff --git a/ebean-core/src/test/java/io/ebean/server/type/MySex.java b/ebean-test/src/test/java/io/ebean/server/type/MySex.java
similarity index 100%
rename from ebean-core/src/test/java/io/ebean/server/type/MySex.java
rename to ebean-test/src/test/java/io/ebean/server/type/MySex.java
diff --git a/ebean-test/src/test/java/io/ebean/test/DbJsonTest.java b/ebean-test/src/test/java/io/ebean/test/DbJsonTest.java
index 365c019cd..17ecd262b 100644
--- a/ebean-test/src/test/java/io/ebean/test/DbJsonTest.java
+++ b/ebean-test/src/test/java/io/ebean/test/DbJsonTest.java
@@ -2,8 +2,8 @@ package io.ebean.test;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import io.ebean.DB;
-import org.junit.Test;
-import org.test.BSimpleWithGen;
+import org.etest.BSimpleFor;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -16,9 +16,9 @@ public class DbJsonTest {
   @Test
   public void of() {
 
-    DB.find(BSimpleWithGen.class).delete();
+    DB.find(BSimpleFor.class).delete();
 
-    BSimpleWithGen bean = new BSimpleWithGen("something");
+    BSimpleFor bean = new BSimpleFor("something");
     DB.save(bean);
 
     assertThat(bean.getVersion()).isEqualTo(1);
@@ -29,10 +29,10 @@ public class DbJsonTest {
       .assertContentMatches("/bean/example-bean.json");
 
 
-    BSimpleWithGen bean2 = new BSimpleWithGen("other");
+    BSimpleFor bean2 = new BSimpleFor("other");
     DB.save(bean2);
 
-    final List<BSimpleWithGen> beans = DB.find(BSimpleWithGen.class).findList();
+    final List<BSimpleFor> beans = DB.find(BSimpleFor.class).findList();
 
     DbJson.of(beans)
       //.withPlaceholder("_")
@@ -43,10 +43,10 @@ public class DbJsonTest {
   @Test
   public void assertContains_pass() {
 
-    BSimpleWithGen bean = new BSimpleWithGen("something-contains-me", "YeahNah");
+    BSimpleFor bean = new BSimpleFor("something-contains-me", "YeahNah");
     DB.save(bean);
 
-    BSimpleWithGen found = DB.find(BSimpleWithGen.class, bean.getId());
+    BSimpleFor found = DB.find(BSimpleFor.class, bean.getId());
 
     DbJson.of(found).assertContainsResource("/bean/contains-minimal.json");
     DbJson.of(found).assertContains(readResource("/bean/contains-with-version.json"));
@@ -57,7 +57,7 @@ public class DbJsonTest {
   @Test
   public void asJson() {
 
-    BSimpleWithGen bean = new BSimpleWithGen("other");
+    BSimpleFor bean = new BSimpleFor("other");
     DB.save(bean);
 
     String asJson = DbJson.of(bean)
diff --git a/ebean-test/src/test/java/io/ebean/test/JsonAssertContainsTest.java b/ebean-test/src/test/java/io/ebean/test/JsonAssertContainsTest.java
index 7f78c3782..1a2b9da5e 100644
--- a/ebean-test/src/test/java/io/ebean/test/JsonAssertContainsTest.java
+++ b/ebean-test/src/test/java/io/ebean/test/JsonAssertContainsTest.java
@@ -2,7 +2,7 @@ package io.ebean.test;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import org.assertj.core.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.stream.Stream;
 
diff --git a/ebean-test/src/test/java/io/ebean/test/JsonTest.java b/ebean-test/src/test/java/io/ebean/test/JsonTest.java
index baf7a1563..430dc1bff 100644
--- a/ebean-test/src/test/java/io/ebean/test/JsonTest.java
+++ b/ebean-test/src/test/java/io/ebean/test/JsonTest.java
@@ -1,8 +1,8 @@
 package io.ebean.test;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import org.junit.Test;
-import org.test.PlainBean;
+import org.etest.PlainBean;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
diff --git a/ebean-test/src/test/java/io/ebean/test/UserContextTest.java b/ebean-test/src/test/java/io/ebean/test/UserContextTest.java
index 750a256e0..71dd478cb 100644
--- a/ebean-test/src/test/java/io/ebean/test/UserContextTest.java
+++ b/ebean-test/src/test/java/io/ebean/test/UserContextTest.java
@@ -1,8 +1,9 @@
 package io.ebean.test;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class UserContextTest {
 
diff --git a/ebean-test/src/test/java/io/ebean/test/config/platform/ConfigTest.java b/ebean-test/src/test/java/io/ebean/test/config/platform/ConfigTest.java
index d4b23d844..b9cbae900 100644
--- a/ebean-test/src/test/java/io/ebean/test/config/platform/ConfigTest.java
+++ b/ebean-test/src/test/java/io/ebean/test/config/platform/ConfigTest.java
@@ -2,8 +2,8 @@ package io.ebean.test.config.platform;
 
 import io.ebean.config.DatabaseConfig;
 import io.ebean.datasource.DataSourceConfig;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import java.util.Properties;
 
@@ -145,7 +145,7 @@ public class ConfigTest {
     assertThat(config.ignoreDockerShutdown("./src/test/resources/file-does-not-exist")).isFalse();
   }
 
-  @Ignore
+  @Disabled
   @Test
   public void run_local_only_ignoreDockerShutdown() {
 
diff --git a/ebean-test/src/test/java/io/ebean/test/config/provider/ProviderAutoConfigTest.java b/ebean-test/src/test/java/io/ebean/test/config/provider/ProviderAutoConfigTest.java
index 3468e9698..1ff9d0816 100644
--- a/ebean-test/src/test/java/io/ebean/test/config/provider/ProviderAutoConfigTest.java
+++ b/ebean-test/src/test/java/io/ebean/test/config/provider/ProviderAutoConfigTest.java
@@ -1,13 +1,13 @@
 package io.ebean.test.config.provider;
 
-import io.ebean.config.ServerConfig;
-import org.junit.Test;
+import io.ebean.config.DatabaseConfig;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ProviderAutoConfigTest {
 
-  private ProviderAutoConfig config = new ProviderAutoConfig(new ServerConfig());
+  private final ProviderAutoConfig config = new ProviderAutoConfig(new DatabaseConfig());
 
   @Test
   public void msg() {
diff --git a/ebean-core/src/test/java/io/ebean/text/PathPropertiesTests.java b/ebean-test/src/test/java/io/ebean/text/PathPropertiesTests.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebean/text/PathPropertiesTests.java
rename to ebean-test/src/test/java/io/ebean/text/PathPropertiesTests.java
index 13acc6376..2fb3b5fce 100644
--- a/ebean-core/src/test/java/io/ebean/text/PathPropertiesTests.java
+++ b/ebean-test/src/test/java/io/ebean/text/PathPropertiesTests.java
@@ -3,7 +3,7 @@ package io.ebean.text;
 import io.ebean.DB;
 import io.ebean.FetchPath;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Customer;
@@ -12,9 +12,7 @@ import org.tests.model.basic.ResetBasicData;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class PathPropertiesTests {
 
diff --git a/ebean-core/src/test/java/io/ebean/text/json/JsonBeanReaderTest.java b/ebean-test/src/test/java/io/ebean/text/json/JsonBeanReaderTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebean/text/json/JsonBeanReaderTest.java
rename to ebean-test/src/test/java/io/ebean/text/json/JsonBeanReaderTest.java
index df6530e16..6cf8f52db 100644
--- a/ebean-core/src/test/java/io/ebean/text/json/JsonBeanReaderTest.java
+++ b/ebean-test/src/test/java/io/ebean/text/json/JsonBeanReaderTest.java
@@ -1,11 +1,11 @@
 package io.ebean.text.json;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.bean.PersistenceContext;
-import org.tests.model.basic.Customer;
 import com.fasterxml.jackson.core.JsonParser;
-import org.junit.Test;
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.bean.PersistenceContext;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Customer;
 
 import java.io.StringReader;
 
@@ -14,7 +14,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class JsonBeanReaderTest extends BaseTestCase {
 
-  static JsonContext json = Ebean.json();
+  static JsonContext json = DB.json();
 
   @Test
   public void read() {
diff --git a/ebean-core/src/test/java/io/ebean/text/json/JsonContextTest.java b/ebean-test/src/test/java/io/ebean/text/json/JsonContextTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebean/text/json/JsonContextTest.java
rename to ebean-test/src/test/java/io/ebean/text/json/JsonContextTest.java
index 8d099565b..bb1b4056d 100644
--- a/ebean-core/src/test/java/io/ebean/text/json/JsonContextTest.java
+++ b/ebean-test/src/test/java/io/ebean/text/json/JsonContextTest.java
@@ -3,7 +3,7 @@ package io.ebean.text.json;
 import com.fasterxml.jackson.core.JsonGenerator;
 import io.ebean.DB;
 import io.ebean.text.PathProperties;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
@@ -15,11 +15,7 @@ import java.util.List;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class JsonContextTest {
 
@@ -201,9 +197,9 @@ public class JsonContextTest {
     generator.close();
 
     String jsonString = writer.toString();
-    assertTrue(jsonString, jsonString.startsWith("["));
-    assertTrue(jsonString, jsonString.endsWith("]"));
-    assertTrue(jsonString, jsonString.contains("{\"id\":1,\"name\":\"Jim\"}"));
+    assertThat(jsonString).startsWith("[");
+    assertThat(jsonString).endsWith("]");
+    assertThat(jsonString).contains("{\"id\":1,\"name\":\"Jim\"}");
   }
 
   @Test
diff --git a/ebean-core/src/test/java/io/ebean/text/json/JsonWriteOptionsTests.java b/ebean-test/src/test/java/io/ebean/text/json/JsonWriteOptionsTests.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebean/text/json/JsonWriteOptionsTests.java
rename to ebean-test/src/test/java/io/ebean/text/json/JsonWriteOptionsTests.java
index 1714d0ddb..4076d82a9 100644
--- a/ebean-core/src/test/java/io/ebean/text/json/JsonWriteOptionsTests.java
+++ b/ebean-test/src/test/java/io/ebean/text/json/JsonWriteOptionsTests.java
@@ -1,12 +1,12 @@
 package io.ebean.text.json;
 
 import io.ebean.FetchPath;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Set;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class JsonWriteOptionsTests {
 
diff --git a/ebean-core/src/test/java/io/ebean/util/CamelCaseHelperTest.java b/ebean-test/src/test/java/io/ebean/util/CamelCaseHelperTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebean/util/CamelCaseHelperTest.java
rename to ebean-test/src/test/java/io/ebean/util/CamelCaseHelperTest.java
index 3341071e9..134bbb356 100644
--- a/ebean-core/src/test/java/io/ebean/util/CamelCaseHelperTest.java
+++ b/ebean-test/src/test/java/io/ebean/util/CamelCaseHelperTest.java
@@ -1,8 +1,8 @@
 package io.ebean.util;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class CamelCaseHelperTest {
 
diff --git a/ebean-core/src/test/java/org/tests/unitinternal/TestEncodeB64.java b/ebean-test/src/test/java/io/ebean/util/TestEncodeB64.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/unitinternal/TestEncodeB64.java
rename to ebean-test/src/test/java/io/ebean/util/TestEncodeB64.java
index 95124fcad..54f024308 100644
--- a/ebean-core/src/test/java/org/tests/unitinternal/TestEncodeB64.java
+++ b/ebean-test/src/test/java/io/ebean/util/TestEncodeB64.java
@@ -1,9 +1,9 @@
-package org.tests.unitinternal;
+package io.ebean.util;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static io.ebean.util.EncodeB64.enc;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestEncodeB64 {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/api/BindParamsTest.java b/ebean-test/src/test/java/io/ebeaninternal/api/BindParamsTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/api/BindParamsTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/api/BindParamsTest.java
index 0705324c1..eef160dd7 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/api/BindParamsTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/api/BindParamsTest.java
@@ -1,11 +1,11 @@
 package io.ebeaninternal.api;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class BindParamsTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/api/HelpScopeTransTest.java b/ebean-test/src/test/java/io/ebeaninternal/api/HelpScopeTransTest.java
similarity index 76%
rename from ebean-core/src/test/java/io/ebeaninternal/api/HelpScopeTransTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/api/HelpScopeTransTest.java
index 6e7862580..51a46d3bf 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/api/HelpScopeTransTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/api/HelpScopeTransTest.java
@@ -1,14 +1,15 @@
 package io.ebeaninternal.api;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.TxScope;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 import org.tests.model.basic.UUOne;
 
+import static org.junit.jupiter.api.Assertions.assertNull;
+
 public class HelpScopeTransTest {
 
   @Test
@@ -19,16 +20,16 @@ public class HelpScopeTransTest {
     HelpScopeTrans.enter(TxScope.required());
     HelpScopeTrans.enter(TxScope.required());
 
-    Ebean.find(Customer.class).findList();
+    DB.find(Customer.class).findList();
 
     HelpScopeTrans.enter(TxScope.required());
-    Ebean.find(Contact.class).findList();
+    DB.find(Contact.class).findList();
 
     HelpScopeTrans.exit(null, 1);
 
     UUOne one = new UUOne();
     one.setName("junk");
-    Ebean.save(one);
+    DB.save(one);
 
     HelpScopeTrans.exit(null, 1);
     HelpScopeTrans.exit(null, 1);
@@ -40,7 +41,7 @@ public class HelpScopeTransTest {
 
     try {
       HelpScopeTrans.enter(TxScope.required());
-      Assert.assertNull(Ebean.getDefaultServer().currentTransaction());
+      assertNull(DB.getDefault().currentTransaction());
       HelpScopeTrans.exit(null, 1);
     } finally {
       HelpScopeTrans.setEnabled(true);
diff --git a/ebean-core/src/test/java/io/ebeaninternal/api/PlatformMatchTest.java b/ebean-test/src/test/java/io/ebeaninternal/api/PlatformMatchTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/api/PlatformMatchTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/api/PlatformMatchTest.java
index b33125b49..d20108a20 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/api/PlatformMatchTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/api/PlatformMatchTest.java
@@ -1,9 +1,10 @@
 package io.ebeaninternal.api;
 
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class PlatformMatchTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/api/TDSpiEbeanServer.java b/ebean-test/src/test/java/io/ebeaninternal/api/TDSpiEbeanServer.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/api/TDSpiEbeanServer.java
rename to ebean-test/src/test/java/io/ebeaninternal/api/TDSpiEbeanServer.java
index cb7e613a3..17bd8f19b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/api/TDSpiEbeanServer.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/api/TDSpiEbeanServer.java
@@ -1,41 +1,12 @@
 package io.ebeaninternal.api;
 
-import io.ebean.AutoTune;
-import io.ebean.BackgroundExecutor;
-import io.ebean.BeanState;
-import io.ebean.CallableSql;
-import io.ebean.DocumentStore;
-import io.ebean.DtoQuery;
-import io.ebean.ExpressionFactory;
-import io.ebean.ExtendedServer;
-import io.ebean.Filter;
-import io.ebean.FutureIds;
-import io.ebean.FutureList;
-import io.ebean.FutureRowCount;
-import io.ebean.MergeOptions;
-import io.ebean.PagedList;
-import io.ebean.PersistenceContextScope;
-import io.ebean.Query;
-import io.ebean.QueryIterator;
-import io.ebean.RowConsumer;
-import io.ebean.RowMapper;
-import io.ebean.ScriptRunner;
-import io.ebean.SqlQuery;
-import io.ebean.SqlRow;
-import io.ebean.SqlUpdate;
-import io.ebean.Transaction;
-import io.ebean.TransactionCallback;
-import io.ebean.TxScope;
-import io.ebean.Update;
-import io.ebean.UpdateQuery;
-import io.ebean.ValuePair;
-import io.ebean.Version;
+import io.ebean.*;
 import io.ebean.annotation.Platform;
 import io.ebean.annotation.TxIsolation;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.CallOrigin;
 import io.ebean.cache.ServerCacheManager;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.event.readaudit.ReadAuditLogger;
 import io.ebean.event.readaudit.ReadAuditPrepare;
@@ -56,12 +27,7 @@ import javax.persistence.OptimisticLockException;
 import javax.persistence.PersistenceException;
 import javax.sql.DataSource;
 import java.time.Clock;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.Callable;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
@@ -71,7 +37,7 @@ import java.util.stream.Stream;
 /**
  * Test double for SpiEbeanServer.
  */
-public class TDSpiEbeanServer implements SpiEbeanServer {
+public class TDSpiEbeanServer extends TDSpiServer implements SpiEbeanServer {
 
   String name;
 
@@ -138,17 +104,17 @@ public class TDSpiEbeanServer implements SpiEbeanServer {
   }
 
   @Override
-  public DataTimeZone getDataTimeZone() {
+  public DataTimeZone dataTimeZone() {
     return null;
   }
 
   @Override
-  public Platform getPlatform() {
+  public Platform platform() {
     return Platform.GENERIC;
   }
 
   @Override
-  public SpiServer getPluginApi() {
+  public SpiServer pluginApi() {
     return null;
   }
 
@@ -158,12 +124,12 @@ public class TDSpiEbeanServer implements SpiEbeanServer {
   }
 
   @Override
-  public ServerConfig getServerConfig() {
+  public DatabaseConfig config() {
     return null;
   }
 
   @Override
-  public DatabasePlatform getDatabasePlatform() {
+  public DatabasePlatform databasePlatform() {
     return null;
   }
 
@@ -173,7 +139,7 @@ public class TDSpiEbeanServer implements SpiEbeanServer {
   }
 
   @Override
-  public PersistenceContextScope getPersistenceContextScope(SpiQuery<?> query) {
+  public PersistenceContextScope persistenceContextScope(SpiQuery<?> query) {
     return null;
   }
 
@@ -183,12 +149,12 @@ public class TDSpiEbeanServer implements SpiEbeanServer {
   }
 
   @Override
-  public ReadAuditLogger getReadAuditLogger() {
+  public ReadAuditLogger readAuditLogger() {
     return null;
   }
 
   @Override
-  public ReadAuditPrepare getReadAuditPrepare() {
+  public ReadAuditPrepare readAuditPrepare() {
     return null;
   }
 
@@ -198,32 +164,32 @@ public class TDSpiEbeanServer implements SpiEbeanServer {
   }
 
   @Override
-  public BeanDescriptor<?> getBeanDescriptorByQueueId(String queueId) {
+  public BeanDescriptor<?> descriptorByQueueId(String queueId) {
     return null;
   }
 
   @Override
-  public SpiTransactionManager getTransactionManager() {
+  public SpiTransactionManager transactionManager() {
     return null;
   }
 
   @Override
-  public List<BeanDescriptor<?>> getBeanDescriptors() {
+  public List<BeanDescriptor<?>> descriptors() {
     return null;
   }
 
   @Override
-  public <T> BeanDescriptor<T> getBeanDescriptor(Class<T> type) {
+  public <T> BeanDescriptor<T> descriptor(Class<T> type) {
     return null;
   }
 
   @Override
-  public BeanDescriptor<?> getBeanDescriptorById(String descriptorId) {
+  public BeanDescriptor<?> descriptorById(String descriptorId) {
     return null;
   }
 
   @Override
-  public List<BeanDescriptor<?>> getBeanDescriptors(String tableName) {
+  public List<BeanDescriptor<?>> descriptors(String tableName) {
     return null;
   }
 
@@ -311,7 +277,7 @@ public class TDSpiEbeanServer implements SpiEbeanServer {
   }
 
   @Override
-  public int getLazyLoadBatchSize() {
+  public int lazyLoadBatchSize() {
     return 0;
   }
 
@@ -333,47 +299,47 @@ public class TDSpiEbeanServer implements SpiEbeanServer {
   }
 
   @Override
-  public AutoTune getAutoTune() {
+  public AutoTune autoTune() {
     return null;
   }
 
   @Override
-  public DataSource getDataSource() {
+  public DataSource dataSource() {
     return null;
   }
 
   @Override
-  public DataSource getReadOnlyDataSource() {
+  public DataSource readOnlyDataSource() {
     return null;
   }
 
   @Override
-  public String getName() {
+  public String name() {
     return name;
   }
 
   @Override
-  public ExpressionFactory getExpressionFactory() {
+  public ExpressionFactory expressionFactory() {
     return null;
   }
 
   @Override
-  public MetaInfoManager getMetaInfoManager() {
+  public MetaInfoManager metaInfo() {
     return null;
   }
 
   @Override
-  public BeanState getBeanState(Object bean) {
+  public BeanState beanState(Object bean) {
     return null;
   }
 
   @Override
-  public Object setBeanId(Object bean, Object id) {
+  public Object beanId(Object bean, Object id) {
     return id;
   }
 
   @Override
-  public Object getBeanId(Object bean) {
+  public Object beanId(Object bean) {
     return null;
   }
 
@@ -660,7 +626,7 @@ public class TDSpiEbeanServer implements SpiEbeanServer {
   }
 
   @Override
-  public <T> T getReference(Class<T> beanType, Object id) {
+  public <T> T reference(Class<T> beanType, Object id) {
     return null;
   }
 
@@ -919,12 +885,12 @@ public class TDSpiEbeanServer implements SpiEbeanServer {
   }
 
   @Override
-  public ServerCacheManager getServerCacheManager() {
+  public ServerCacheManager cacheManager() {
     return null;
   }
 
   @Override
-  public BackgroundExecutor getBackgroundExecutor() {
+  public BackgroundExecutor backgroundExecutor() {
     return null;
   }
 
diff --git a/ebean-test/src/test/java/io/ebeaninternal/api/TDSpiServer.java b/ebean-test/src/test/java/io/ebeaninternal/api/TDSpiServer.java
new file mode 100644
index 000000000..620e9664a
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebeaninternal/api/TDSpiServer.java
@@ -0,0 +1,647 @@
+package io.ebeaninternal.api;
+
+import io.ebean.*;
+import io.ebean.annotation.Platform;
+import io.ebean.annotation.TxIsolation;
+import io.ebean.bean.BeanLoader;
+import io.ebean.bean.EntityBeanIntercept;
+import io.ebean.cache.ServerCacheManager;
+import io.ebean.config.DatabaseConfig;
+import io.ebean.config.dbplatform.DatabasePlatform;
+import io.ebean.meta.MetaInfoManager;
+import io.ebean.plugin.BeanType;
+import io.ebean.plugin.Property;
+import io.ebean.plugin.SpiServer;
+import io.ebean.text.csv.CsvReader;
+import io.ebean.text.json.JsonContext;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.persistence.OptimisticLockException;
+import javax.persistence.PersistenceException;
+import javax.sql.DataSource;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+
+public class TDSpiServer implements SpiServer {
+  @Override
+  public void shutdown() {
+
+  }
+
+  @Override
+  public void shutdown(boolean shutdownDataSource, boolean deregisterDriver) {
+
+  }
+
+  @Override
+  public AutoTune autoTune() {
+    return null;
+  }
+
+  @Override
+  public DataSource dataSource() {
+    return null;
+  }
+
+  @Override
+  public DataSource readOnlyDataSource() {
+    return null;
+  }
+
+  @Override
+  public String name() {
+    return null;
+  }
+
+  @Override
+  public ExpressionFactory expressionFactory() {
+    return null;
+  }
+
+  @Override
+  public MetaInfoManager metaInfo() {
+    return null;
+  }
+
+  @Override
+  public Platform platform() {
+    return null;
+  }
+
+  @Override
+  public SpiServer pluginApi() {
+    return null;
+  }
+
+  @Override
+  public BeanState beanState(Object bean) {
+    return null;
+  }
+
+  @Override
+  public Object beanId(Object bean) {
+    return null;
+  }
+
+  @Override
+  public Object beanId(Object bean, Object id) {
+    return null;
+  }
+
+  @Override
+  public Map<String, ValuePair> diff(Object newBean, Object oldBean) {
+    return null;
+  }
+
+  @Override
+  public <T> T createEntityBean(Class<T> type) {
+    return null;
+  }
+
+  @Override
+  public <T> CsvReader<T> createCsvReader(Class<T> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> UpdateQuery<T> update(Class<T> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery) {
+    return null;
+  }
+
+  @Override
+  public <T> Query<T> createQuery(Class<T> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> Query<T> createQuery(Class<T> beanType, String ormQuery) {
+    return null;
+  }
+
+  @Override
+  public <T> Query<T> find(Class<T> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> Query<T> findNative(Class<T> beanType, String nativeSql) {
+    return null;
+  }
+
+  @Override
+  public void lock(Object bean) {
+  }
+
+  @Override
+  public Object nextId(Class<?> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> Filter<T> filter(Class<T> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> void sort(List<T> list, String sortByClause) {
+
+  }
+
+  @Override
+  public <T> Update<T> createUpdate(Class<T> beanType, String ormUpdate) {
+    return null;
+  }
+
+  @Override
+  public <T> DtoQuery<T> findDto(Class<T> dtoType, String sql) {
+    return null;
+  }
+
+  @Override
+  public <T> DtoQuery<T> createNamedDtoQuery(Class<T> dtoType, String namedQuery) {
+    return null;
+  }
+
+  @Override
+  public SqlQuery sqlQuery(String sql) {
+    return null;
+  }
+
+  @Override
+  public SqlQuery createSqlQuery(String sql) {
+    return null;
+  }
+
+  @Override
+  public SqlUpdate sqlUpdate(String sql) {
+    return null;
+  }
+
+  @Override
+  public SqlUpdate createSqlUpdate(String sql) {
+    return null;
+  }
+
+  @Override
+  public CallableSql createCallableSql(String callableSql) {
+    return null;
+  }
+
+  @Override
+  public void register(TransactionCallback transactionCallback) throws PersistenceException {
+
+  }
+
+  @Override
+  public Transaction createTransaction() {
+    return null;
+  }
+
+  @Override
+  public Transaction createTransaction(TxIsolation isolation) {
+    return null;
+  }
+
+  @Override
+  public Transaction beginTransaction() {
+    return null;
+  }
+
+  @Override
+  public Transaction beginTransaction(TxIsolation isolation) {
+    return null;
+  }
+
+  @Override
+  public Transaction beginTransaction(TxScope scope) {
+    return null;
+  }
+
+  @Override
+  public Transaction currentTransaction() {
+    return null;
+  }
+
+  @Override
+  public void flush() {
+
+  }
+
+  @Override
+  public void commitTransaction() {
+
+  }
+
+  @Override
+  public void rollbackTransaction() {
+
+  }
+
+  @Override
+  public void endTransaction() {
+
+  }
+
+  @Override
+  public void refresh(Object bean) {
+
+  }
+
+  @Override
+  public void refreshMany(Object bean, String propertyName) {
+
+  }
+
+  @Nullable
+  @Override
+  public <T> T find(Class<T> beanType, Object id) {
+    return null;
+  }
+
+  @Nonnull
+  @Override
+  public <T> T reference(Class<T> beanType, Object id) {
+    return null;
+  }
+
+  @Override
+  public ExtendedServer extended() {
+    return null;
+  }
+
+  @Override
+  public void save(Object bean) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public int saveAll(Collection<?> beans) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public int saveAll(Object... beans) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public boolean delete(Object bean) throws OptimisticLockException {
+    return false;
+  }
+
+  @Override
+  public boolean delete(Object bean, Transaction transaction) throws OptimisticLockException {
+    return false;
+  }
+
+  @Override
+  public boolean deletePermanent(Object bean) throws OptimisticLockException {
+    return false;
+  }
+
+  @Override
+  public boolean deletePermanent(Object bean, Transaction transaction) throws OptimisticLockException {
+    return false;
+  }
+
+  @Override
+  public int deleteAllPermanent(Collection<?> beans) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public int deleteAllPermanent(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public int delete(Class<?> beanType, Object id) {
+    return 0;
+  }
+
+  @Override
+  public int delete(Class<?> beanType, Object id, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public int deletePermanent(Class<?> beanType, Object id) {
+    return 0;
+  }
+
+  @Override
+  public int deletePermanent(Class<?> beanType, Object id, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public int deleteAll(Collection<?> beans) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public int deleteAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public int deleteAll(Class<?> beanType, Collection<?> ids) {
+    return 0;
+  }
+
+  @Override
+  public int deleteAll(Class<?> beanType, Collection<?> ids, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public int deleteAllPermanent(Class<?> beanType, Collection<?> ids) {
+    return 0;
+  }
+
+  @Override
+  public int deleteAllPermanent(Class<?> beanType, Collection<?> ids, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public int execute(SqlUpdate sqlUpdate) {
+    return 0;
+  }
+
+  @Override
+  public int execute(Update<?> update) {
+    return 0;
+  }
+
+  @Override
+  public int execute(Update<?> update, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public int execute(CallableSql callableSql) {
+    return 0;
+  }
+
+  @Override
+  public void externalModification(String tableName, boolean inserted, boolean updated, boolean deleted) {
+
+  }
+
+  @Override
+  public <T> T find(Class<T> beanType, Object id, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public void save(Object bean, Transaction transaction) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public int saveAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Nonnull
+  @Override
+  public Set<Property> checkUniqueness(Object bean) {
+    return null;
+  }
+
+  @Nonnull
+  @Override
+  public Set<Property> checkUniqueness(Object bean, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public void markAsDirty(Object bean) {
+
+  }
+
+  @Override
+  public void update(Object bean) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public void update(Object bean, Transaction transaction) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public void updateAll(Collection<?> beans) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public void updateAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public void merge(Object bean) {
+
+  }
+
+  @Override
+  public void merge(Object bean, MergeOptions options) {
+
+  }
+
+  @Override
+  public void merge(Object bean, MergeOptions options, Transaction transaction) {
+
+  }
+
+  @Override
+  public void insert(Object bean) {
+
+  }
+
+  @Override
+  public void insert(Object bean, Transaction transaction) {
+
+  }
+
+  @Override
+  public void insertAll(Collection<?> beans) {
+
+  }
+
+  @Override
+  public void insertAll(Collection<?> beans, Transaction transaction) {
+
+  }
+
+  @Override
+  public int execute(SqlUpdate updSql, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public int execute(CallableSql callableSql, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public void execute(TxScope scope, Runnable runnable) {
+
+  }
+
+  @Override
+  public void execute(Runnable runnable) {
+
+  }
+
+  @Override
+  public <T> T executeCall(TxScope scope, Callable<T> callable) {
+    return null;
+  }
+
+  @Override
+  public <T> T executeCall(Callable<T> callable) {
+    return null;
+  }
+
+  @Override
+  public ServerCacheManager cacheManager() {
+    return null;
+  }
+
+  @Override
+  public BackgroundExecutor backgroundExecutor() {
+    return null;
+  }
+
+  @Override
+  public JsonContext json() {
+    return null;
+  }
+
+  @Override
+  public ScriptRunner script() {
+    return null;
+  }
+
+  @Override
+  public DocumentStore docStore() {
+    return null;
+  }
+
+  @Override
+  public <T> T publish(Class<T> beanType, Object id, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> T publish(Class<T> beanType, Object id) {
+    return null;
+  }
+
+  @Override
+  public <T> List<T> publish(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> List<T> publish(Query<T> query) {
+    return null;
+  }
+
+  @Override
+  public <T> T draftRestore(Class<T> beanType, Object id, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> T draftRestore(Class<T> beanType, Object id) {
+    return null;
+  }
+
+  @Override
+  public <T> List<T> draftRestore(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> List<T> draftRestore(Query<T> query) {
+    return null;
+  }
+
+  @Override
+  public <T> Set<String> validateQuery(Query<T> query) {
+    return null;
+  }
+
+  @Override
+  public void truncate(String... tables) {
+
+  }
+
+  @Override
+  public void truncate(Class<?>... tables) {
+
+  }
+
+  @Override
+  public DatabaseConfig config() {
+    return null;
+  }
+
+  @Override
+  public DatabasePlatform databasePlatform() {
+    return null;
+  }
+
+  @Override
+  public List<? extends BeanType<?>> beanTypes() {
+    return null;
+  }
+
+  @Override
+  public <T> BeanType<T> beanType(Class<T> beanClass) {
+    return null;
+  }
+
+  @Override
+  public List<? extends BeanType<?>> beanTypes(String baseTableName) {
+    return null;
+  }
+
+  @Override
+  public BeanType<?> beanTypeForQueueId(String queueId) {
+    return null;
+  }
+
+  @Override
+  public BeanLoader beanLoader() {
+    return null;
+  }
+
+  @Override
+  public void loadBeanRef(EntityBeanIntercept ebi) {
+
+  }
+
+  @Override
+  public void loadBeanL2(EntityBeanIntercept ebi) {
+
+  }
+
+  @Override
+  public void loadBean(EntityBeanIntercept ebi) {
+
+  }
+}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/extraddl/model/ExtraDdlXmlReaderTest.java b/ebean-test/src/test/java/io/ebeaninternal/extraddl/model/ExtraDdlXmlReaderTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/extraddl/model/ExtraDdlXmlReaderTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/extraddl/model/ExtraDdlXmlReaderTest.java
index cf4b284fe..a0bd66adb 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/extraddl/model/ExtraDdlXmlReaderTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/extraddl/model/ExtraDdlXmlReaderTest.java
@@ -1,12 +1,10 @@
 package io.ebeaninternal.extraddl.model;
 
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class ExtraDdlXmlReaderTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/json/ModifyAwareMapTest.java b/ebean-test/src/test/java/io/ebeaninternal/json/ModifyAwareMapTest.java
similarity index 82%
rename from ebean-core/src/test/java/io/ebeaninternal/json/ModifyAwareMapTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/json/ModifyAwareMapTest.java
index a9bfbb929..507475e27 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/json/ModifyAwareMapTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/json/ModifyAwareMapTest.java
@@ -1,23 +1,13 @@
 package io.ebeaninternal.json;
 
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Set;
+import java.io.*;
+import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ModifyAwareMapTest {
 
@@ -50,7 +40,7 @@ public class ModifyAwareMapTest {
     assertFalse(map.isMarkedDirty());
 
     map.put("A", "change");
-    Assert.assertTrue(map.isMarkedDirty());
+    assertTrue(map.isMarkedDirty());
   }
 
   @Test
@@ -60,7 +50,7 @@ public class ModifyAwareMapTest {
     assertFalse(map.isMarkedDirty());
 
     map.setMarkedDirty(true);
-    Assert.assertTrue(map.isMarkedDirty());
+    assertTrue(map.isMarkedDirty());
   }
 
   @Test
@@ -74,21 +64,21 @@ public class ModifyAwareMapTest {
   public void testIsEmpty() {
 
     assertFalse(createMap().isEmpty());
-    Assert.assertTrue(createEmptyMap().isEmpty());
+    assertTrue(createEmptyMap().isEmpty());
   }
 
   @Test
   public void testContainsKey() {
 
     ModifyAwareMap<String, String> map = createMap();
-    Assert.assertTrue(map.containsKey("A"));
+    assertTrue(map.containsKey("A"));
     assertFalse(map.containsKey("Z"));
   }
 
   @Test
   public void testContainsValue() {
     ModifyAwareMap<String, String> map = createMap();
-    Assert.assertTrue(map.containsValue("one"));
+    assertTrue(map.containsValue("one"));
     assertFalse(map.containsValue("junk"));
   }
 
@@ -98,7 +88,7 @@ public class ModifyAwareMapTest {
     ModifyAwareMap<String, String> map = createMap();
 
     assertEquals("two", map.get("B"));
-    Assert.assertNull(map.get("Z"));
+    assertNull(map.get("Z"));
     assertFalse(map.isMarkedDirty());
   }
 
@@ -109,7 +99,7 @@ public class ModifyAwareMapTest {
     assertFalse(map.isMarkedDirty());
 
     map.put("A", "mod");
-    Assert.assertTrue(map.isMarkedDirty());
+    assertTrue(map.isMarkedDirty());
   }
 
   @Test
@@ -119,7 +109,7 @@ public class ModifyAwareMapTest {
     assertFalse(map.isMarkedDirty());
 
     map.remove("A");
-    Assert.assertTrue(map.isMarkedDirty());
+    assertTrue(map.isMarkedDirty());
   }
 
   @Test
@@ -130,7 +120,7 @@ public class ModifyAwareMapTest {
 
     Map<String, String> other = new HashMap<>();
     map.putAll(other);
-    Assert.assertTrue(map.isMarkedDirty());
+    assertTrue(map.isMarkedDirty());
   }
 
   @Test
@@ -142,7 +132,7 @@ public class ModifyAwareMapTest {
     Map<String, String> other = new HashMap<>();
     other.put("A", "one");
     map.putAll(other);
-    Assert.assertTrue(map.isMarkedDirty());
+    assertTrue(map.isMarkedDirty());
   }
 
   @Test
@@ -152,7 +142,7 @@ public class ModifyAwareMapTest {
     assertFalse(map.isMarkedDirty());
 
     map.clear();
-    Assert.assertTrue(map.isMarkedDirty());
+    assertTrue(map.isMarkedDirty());
   }
 
   @Test
@@ -163,7 +153,7 @@ public class ModifyAwareMapTest {
 
     Set<String> keys = map.keySet();
     assertEquals(map.size(), keys.size());
-    Assert.assertTrue(keys.contains("A"));
+    assertTrue(keys.contains("A"));
     assertFalse(map.isMarkedDirty());
   }
 
@@ -175,7 +165,7 @@ public class ModifyAwareMapTest {
 
     Collection<String> values = map.values();
     assertEquals(map.size(), values.size());
-    Assert.assertTrue(values.contains("one"));
+    assertTrue(values.contains("one"));
     assertFalse(map.isMarkedDirty());
   }
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/cache/CacheBeanDataTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/cache/CacheBeanDataTest.java
similarity index 90%
rename from ebean-core/src/test/java/io/ebeaninternal/server/cache/CacheBeanDataTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/cache/CacheBeanDataTest.java
index 957515f80..4bcb40b8e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/cache/CacheBeanDataTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/cache/CacheBeanDataTest.java
@@ -7,18 +7,18 @@ import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanPropertyAssocOne;
 import io.ebeaninternal.server.transaction.DefaultPersistenceContext;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Customer.Status;
 import org.tests.model.embedded.EAddress;
 import org.tests.model.embedded.EPerson;
-import org.junit.Test;
 
 import java.sql.Timestamp;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class CacheBeanDataTest extends BaseTestCase {
 
@@ -26,7 +26,7 @@ public class CacheBeanDataTest extends BaseTestCase {
   public void extract_load_on_customer() {
 
     SpiEbeanServer server = spiEbeanServer();
-    BeanDescriptor<Customer> desc = server.getBeanDescriptor(Customer.class);
+    BeanDescriptor<Customer> desc = server.descriptor(Customer.class);
 
     Customer c = new Customer();
     c.setId(98989);
@@ -39,7 +39,7 @@ public class CacheBeanDataTest extends BaseTestCase {
     Address billingAddress = new Address();
     billingAddress.setId(12);
     billingAddress.setCity("Auckland");
-    billingAddress.setCountry(server.getReference(Country.class, "NZ"));
+    billingAddress.setCountry(server.reference(Country.class, "NZ"));
     billingAddress.setLine1("92 Someplace Else");
     c.setBillingAddress(billingAddress);
 
@@ -78,8 +78,8 @@ public class CacheBeanDataTest extends BaseTestCase {
   public void extract_load_withEmbeddedBean() {
 
     SpiEbeanServer server = spiEbeanServer();
-    BeanDescriptor<EPerson> desc = server.getBeanDescriptor(EPerson.class);
-    BeanPropertyAssocOne<?> addressBeanProperty = (BeanPropertyAssocOne<?>) desc.getBeanProperty("address");
+    BeanDescriptor<EPerson> desc = server.descriptor(EPerson.class);
+    BeanPropertyAssocOne<?> addressBeanProperty = (BeanPropertyAssocOne<?>) desc.beanProperty("address");
 
     EAddress address = new EAddress();
     address.setStreet("92 Someplace Else");
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataFromBeanTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataFromBeanTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataFromBeanTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataFromBeanTest.java
index 323fcc2e0..cd6114904 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataFromBeanTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataFromBeanTest.java
@@ -5,7 +5,7 @@ import io.ebean.bean.EntityBean;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.transaction.DefaultPersistenceContext;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Car;
 import org.tests.model.basic.Contact;
@@ -15,7 +15,7 @@ import java.sql.Date;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class CachedBeanDataFromBeanTest extends BaseTestCase {
 
@@ -24,7 +24,7 @@ public class CachedBeanDataFromBeanTest extends BaseTestCase {
   @Test
   public void extract() {
 
-    BeanDescriptor<Customer> desc = server.getBeanDescriptor(Customer.class);
+    BeanDescriptor<Customer> desc = server.descriptor(Customer.class);
 
     Date largeDate = new Date(9223372036825200000L);
 
@@ -56,7 +56,7 @@ public class CachedBeanDataFromBeanTest extends BaseTestCase {
     car.setDriver("Jimmy");
     car.setNotes("some notes");
 
-    BeanDescriptor<Car> carDesc = server.getBeanDescriptor(Car.class);
+    BeanDescriptor<Car> carDesc = server.descriptor(Car.class);
     CachedBeanData cacheData = CachedBeanDataFromBean.extract(carDesc, (EntityBean) car);
 
     Car newCar = new Car();
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataSerializeTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataSerializeTest.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataSerializeTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataSerializeTest.java
index 8f94c27af..53bf0c21d 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataSerializeTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/cache/CachedBeanDataSerializeTest.java
@@ -1,27 +1,23 @@
 package io.ebeaninternal.server.cache;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.EntityBean;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.transaction.DefaultPersistenceContext;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 import org.tests.model.basic.TBytesOnly;
-import org.junit.Test;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
+import java.io.*;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 
 public class CachedBeanDataSerializeTest extends BaseTestCase {
@@ -64,7 +60,7 @@ public class CachedBeanDataSerializeTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> customers = Ebean.find(Customer.class)
+    List<Customer> customers = DB.find(Customer.class)
       .order().asc("id")
       .setMaxRows(1).findList();
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolderTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolderTest.java
similarity index 84%
rename from ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolderTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolderTest.java
index d88f42719..3a61f60ee 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolderTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolderTest.java
@@ -3,9 +3,9 @@ package io.ebeaninternal.server.cache;
 import io.ebean.cache.ServerCacheFactory;
 import io.ebean.cache.ServerCacheOptions;
 import io.ebean.cache.ServerCacheType;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
 import io.ebeaninternal.server.transaction.TableModState;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 
@@ -14,13 +14,13 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class DefaultCacheHolderTest {
 
-  private ThreadLocal<String> tenantId = new ThreadLocal<>();
+  private final ThreadLocal<String> tenantId = new ThreadLocal<>();
 
   private final ServerCacheFactory cacheFactory = new DefaultServerCacheFactory();
   private final ServerCacheOptions defaultOptions = new ServerCacheOptions();
 
   private CacheManagerOptions options() {
-    return new CacheManagerOptions(null, new ServerConfig(), true)
+    return new CacheManagerOptions(null, new DatabaseConfig(), true)
       .with(defaultOptions, defaultOptions)
       .with(cacheFactory, new TableModState());
   }
@@ -82,25 +82,22 @@ public class DefaultCacheHolderTest {
     assertThat(cache.get("1")).isEqualTo("value-for-tenant1");
     assertThat(cache.get("2")).isEqualTo("an other value-for-tenant1");
 
-    Exception exInThread[] = new Exception[1];
-    Thread t = new Thread() {
-      @Override
-      public void run() {
-        try {
-          assertThat(cache.get("1")).isNull();
-          tenantId.set("ten_2");
+    Exception[] exInThread = new Exception[1];
+    Thread t = new Thread(() -> {
+      try {
+        assertThat(cache.get("1")).isNull();
+        tenantId.set("ten_2");
 
-          cache.put("1", "value-for-tenant2");
-          cache.put("2", "an other value-for-tenant2");
+        cache.put("1", "value-for-tenant2");
+        cache.put("2", "an other value-for-tenant2");
 
-          tenantId.set(null);
+        tenantId.set(null);
 
-          cache.clear();
-        } catch (Exception e) {
-          exInThread[0] = e;
-        }
-      };
-    };
+        cache.clear();
+      } catch (Exception e) {
+        exInThread[0] = e;
+      }
+    });
 
     // do some async work
     t.start();
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolder_getCacheOptions_Test.java b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolder_getCacheOptions_Test.java
similarity index 87%
rename from ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolder_getCacheOptions_Test.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolder_getCacheOptions_Test.java
index 6cbc82c8f..f67eef6e8 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolder_getCacheOptions_Test.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolder_getCacheOptions_Test.java
@@ -2,17 +2,17 @@ package io.ebeaninternal.server.cache;
 
 import io.ebean.cache.ServerCacheOptions;
 import io.ebean.cache.ServerCacheType;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Article;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.Product;
-import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DefaultCacheHolder_getCacheOptions_Test {
 
-  private DefaultCacheHolder cacheHolder;
+  private final DefaultCacheHolder cacheHolder;
 
   public DefaultCacheHolder_getCacheOptions_Test() {
 
@@ -20,7 +20,7 @@ public class DefaultCacheHolder_getCacheOptions_Test {
     defaultOptions.setMaxSize(10000);
     defaultOptions.setMaxSecsToLive(120);
 
-    CacheManagerOptions builder = new CacheManagerOptions(null, new ServerConfig(), true)
+    CacheManagerOptions builder = new CacheManagerOptions(null, new DatabaseConfig(), true)
       .with(defaultOptions, defaultOptions);
 
     this.cacheHolder = new DefaultCacheHolder(builder);
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheConfigTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheConfigTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheConfigTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheConfigTest.java
index ecd5ed5c7..512f663fd 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheConfigTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheConfigTest.java
@@ -2,9 +2,9 @@ package io.ebeaninternal.server.cache;
 
 import io.ebean.cache.ServerCacheConfig;
 import io.ebean.cache.ServerCacheOptions;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DefaultServerCacheConfigTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheManagerTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheManagerTest.java
similarity index 86%
rename from ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheManagerTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheManagerTest.java
index 06b12c047..b689d9e50 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheManagerTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheManagerTest.java
@@ -2,18 +2,18 @@ package io.ebeaninternal.server.cache;
 
 import io.ebean.config.ContainerConfig;
 import io.ebean.config.CurrentTenantProvider;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
 import io.ebeaninternal.server.cluster.ClusterManager;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class DefaultServerCacheManagerTest {
 
-  private ThreadLocal<String> tenantId = new ThreadLocal<>();
+  private final ThreadLocal<String> tenantId = new ThreadLocal<>();
 
   class TdTenPro implements CurrentTenantProvider {
 
@@ -23,17 +23,15 @@ public class DefaultServerCacheManagerTest {
     }
   }
 
-  private ClusterManager clusterManager = new ClusterManager(new ContainerConfig());
+  private final ClusterManager clusterManager = new ClusterManager(new ContainerConfig());
 
-  private DefaultServerCacheManager manager = new DefaultServerCacheManager(new CacheManagerOptions(clusterManager, new ServerConfig(), true));
+  private final DefaultServerCacheManager manager = new DefaultServerCacheManager(new CacheManagerOptions(clusterManager, new DatabaseConfig(), true));
 
-  private DefaultServerCacheManager multiTenantManager;
+  private final DefaultServerCacheManager multiTenantManager;
 
   public DefaultServerCacheManagerTest(){
-
-    CacheManagerOptions builder = new CacheManagerOptions(clusterManager, new ServerConfig(), true);
+    CacheManagerOptions builder = new CacheManagerOptions(clusterManager, new DatabaseConfig(), true);
     builder.with(new TdTenPro());
-
     this.multiTenantManager = new DefaultServerCacheManager(builder);
   }
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheTest.java
similarity index 86%
rename from ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheTest.java
index e86a4cea0..87cd7f074 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheTest.java
@@ -3,9 +3,9 @@ package io.ebeaninternal.server.cache;
 import io.ebean.cache.ServerCacheConfig;
 import io.ebean.cache.ServerCacheOptions;
 import io.ebean.cache.ServerCacheType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DefaultServerCacheTest {
 
@@ -26,20 +26,20 @@ public class DefaultServerCacheTest {
   public void testGetHitRatio() {
 
     DefaultServerCache cache = createCache();
-    assertEquals(0, cache.getHitRatio());
+    assertEquals(0, cache.hitRatio());
     assertEquals(0, cache.getHitCount());
     assertEquals(0, cache.getMissCount());
     cache.put("A", "A");
     cache.get("A");
-    assertEquals(100, cache.getHitRatio());
+    assertEquals(100, cache.hitRatio());
     assertEquals(1, cache.getHitCount());
     assertEquals(0, cache.getMissCount());
     cache.get("B");
-    assertEquals(50, cache.getHitRatio());
+    assertEquals(50, cache.hitRatio());
     assertEquals(1, cache.getMissCount());
     cache.get("B");
     cache.get("B");
-    assertEquals(25, cache.getHitRatio());
+    assertEquals(25, cache.hitRatio());
     assertEquals(3, cache.getMissCount());
     assertEquals(1, cache.getHitCount());
   }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCache_RunEvictionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCache_RunEvictionTest.java
similarity index 89%
rename from ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCache_RunEvictionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCache_RunEvictionTest.java
index aa79cf71e..c6596e6d8 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/cache/DefaultServerCache_RunEvictionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/cache/DefaultServerCache_RunEvictionTest.java
@@ -4,8 +4,8 @@ import io.ebean.cache.ServerCacheConfig;
 import io.ebean.cache.ServerCacheOptions;
 import io.ebean.cache.ServerCacheStatistics;
 import io.ebean.cache.ServerCacheType;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import java.util.Random;
 
@@ -33,14 +33,14 @@ public class DefaultServerCache_RunEvictionTest {
     this.cache = createCache();
   }
 
-  @Ignore("test takes long time")
+  @Disabled("test takes long time")
   @Test
   public void runEvict() throws InterruptedException {
 
     for (int i = 0; i < 15; i++) {
       doStuff();
       cache.runEviction();
-      ServerCacheStatistics statistics = cache.getStatistics(true);
+      ServerCacheStatistics statistics = cache.statistics(true);
       System.out.println(statistics);
       Thread.sleep(500);
     }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/changelog/ChangeJsonBuilderTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/changelog/ChangeJsonBuilderTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/server/changelog/ChangeJsonBuilderTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/changelog/ChangeJsonBuilderTest.java
index 0e608f3e1..86bab509f 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/changelog/ChangeJsonBuilderTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/changelog/ChangeJsonBuilderTest.java
@@ -1,11 +1,9 @@
 package io.ebeaninternal.server.changelog;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
 import io.ebean.event.changelog.BeanChange;
 import io.ebean.event.changelog.ChangeSet;
-import io.ebean.text.json.JsonContext;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.StringWriter;
 import java.util.List;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogListenerTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogListenerTest.java
similarity index 69%
rename from ebean-core/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogListenerTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogListenerTest.java
index e13ff7615..75d0a673f 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogListenerTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogListenerTest.java
@@ -1,10 +1,10 @@
 package io.ebeaninternal.server.changelog;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.event.changelog.ChangeSet;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class DefaultChangeLogListenerTest extends BaseTestCase {
 
@@ -15,8 +15,8 @@ public class DefaultChangeLogListenerTest extends BaseTestCase {
 
     DefaultChangeLogListener changeLogListener = new DefaultChangeLogListener();
 
-    EbeanServer defaultServer = Ebean.getDefaultServer();
-    changeLogListener.configure(defaultServer.getPluginApi());
+    Database defaultServer = DB.getDefault();
+    changeLogListener.configure(defaultServer.pluginApi());
 
     ChangeSet changeSet = helper.createChangeSet("INT-001", 13);
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogRegisterTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogRegisterTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogRegisterTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogRegisterTest.java
index 3ebcebea4..d639abf65 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogRegisterTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogRegisterTest.java
@@ -2,15 +2,15 @@ package io.ebeaninternal.server.changelog;
 
 import io.ebean.BaseTestCase;
 import io.ebean.event.changelog.ChangeLogFilter;
+import org.junit.jupiter.api.Test;
 import org.tests.inheritance.model.ProductConfiguration;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.Customer;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class DefaultChangeLogRegisterTest extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/changelog/Helper.java b/ebean-test/src/test/java/io/ebeaninternal/server/changelog/Helper.java
similarity index 100%
rename from ebean-core/src/test/java/io/ebeaninternal/server/changelog/Helper.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/changelog/Helper.java
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/cluster/binarymessage/BinaryTransactionEventReadWriteTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/cluster/binarymessage/BinaryTransactionEventReadWriteTest.java
similarity index 90%
rename from ebean-core/src/test/java/io/ebeaninternal/server/cluster/binarymessage/BinaryTransactionEventReadWriteTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/cluster/binarymessage/BinaryTransactionEventReadWriteTest.java
index 9776ed6a5..c77b855e0 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/cluster/binarymessage/BinaryTransactionEventReadWriteTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/cluster/binarymessage/BinaryTransactionEventReadWriteTest.java
@@ -12,7 +12,7 @@ import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.transaction.BeanPersistIds;
 import io.ebeaninternal.server.transaction.RemoteTableMod;
 import io.ebeaninternal.server.transaction.RemoteTransactionEvent;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import java.io.IOException;
@@ -25,11 +25,9 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class BinaryTransactionEventReadWriteTest extends BaseTestCase {
 
-  private BeanDescriptor<Customer> customerBeanDescriptor = getBeanDescriptor(Customer.class);
-
-  private TDEbeanServer mockEbeanServer = new TDEbeanServer();
-
-  private BinaryTransactionEventReader reader = new BinaryTransactionEventReader(new TDServerLookup());
+  private final BeanDescriptor<Customer> customerBeanDescriptor = getBeanDescriptor(Customer.class);
+  private final TDEbeanServer mockEbeanServer = new TDEbeanServer();
+  private final BinaryTransactionEventReader reader = new BinaryTransactionEventReader(new TDServerLookup());
 
   @Override
   protected <T> BeanDescriptor<T> getBeanDescriptor(Class<T> cls) {
@@ -79,7 +77,6 @@ public class BinaryTransactionEventReadWriteTest extends BaseTestCase {
 
   @Test
   public void readWrite_RemoteTableMod() throws IOException {
-
     RemoteTransactionEvent event = new RemoteTransactionEvent("db");
 
     Set<String> tables = new HashSet<>();
@@ -95,7 +92,6 @@ public class BinaryTransactionEventReadWriteTest extends BaseTestCase {
   }
 
   class TDServerLookup implements ServerLookup {
-
     @Override
     public EbeanServer getServer(String name) {
       return mockEbeanServer;
@@ -104,7 +100,7 @@ public class BinaryTransactionEventReadWriteTest extends BaseTestCase {
 
   class TDEbeanServer extends TDSpiEbeanServer {
     @Override
-    public BeanDescriptor<?> getBeanDescriptorById(String descriptorId) {
+    public BeanDescriptor<?> descriptorById(String descriptorId) {
       return customerBeanDescriptor;
     }
   }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/BasicTypeConverterTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/BasicTypeConverterTest.java
similarity index 82%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/BasicTypeConverterTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/BasicTypeConverterTest.java
index f4a77caf1..0cb2018aa 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/BasicTypeConverterTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/BasicTypeConverterTest.java
@@ -1,9 +1,9 @@
 package io.ebeaninternal.server.core;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class BasicTypeConverterTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/BindPaddingTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/BindPaddingTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/BindPaddingTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/BindPaddingTest.java
index 483963fcc..8fefb770a 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/BindPaddingTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/BindPaddingTest.java
@@ -1,12 +1,12 @@
 package io.ebeaninternal.server.core;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class BindPaddingTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/DefaultServer_createOrmQueryRequestTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/DefaultServer_createOrmQueryRequestTest.java
similarity index 82%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/DefaultServer_createOrmQueryRequestTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/DefaultServer_createOrmQueryRequestTest.java
index 1a5484f16..b600aefc9 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/DefaultServer_createOrmQueryRequestTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/DefaultServer_createOrmQueryRequestTest.java
@@ -2,12 +2,12 @@ package io.ebeaninternal.server.core;
 
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.FetchConfig;
 import io.ebean.Query;
 import io.ebeaninternal.server.querydefn.DefaultOrmQuery;
 import io.ebeaninternal.server.querydefn.OrmQueryDetail;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -23,7 +23,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   }
 
   OrmQueryDetail detail(Query<Order> query) {
-    return queryRequest(query).getQuery().getDetail();
+    return queryRequest(query).query().getDetail();
   }
 
   @Test
@@ -97,13 +97,13 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void when_fetchConfig_then_differentPlan() throws Exception {
 
-    DefaultOrmQuery<Order> query1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class)
+    DefaultOrmQuery<Order> query1 = (DefaultOrmQuery<Order>) DB.find(Order.class)
       .select("status, shipDate")
       .fetchQuery("details", "orderQty, unitPrice")
       .fetch("details.product", "sku, name");
 
 
-    DefaultOrmQuery<Order> query2 = (DefaultOrmQuery<Order>) Ebean.find(Order.class)
+    DefaultOrmQuery<Order> query2 = (DefaultOrmQuery<Order>) DB.find(Order.class)
       .select("status, shipDate")
       .fetch("details", "orderQty, unitPrice")
       .fetch("details.product", "sku, name");
@@ -114,13 +114,13 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void testJoinOrder_when_fetchJoins_expect_detailJoinsPreserveOrder() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status, orderDate")
       .fetch("customer", "name")
       .fetch("details");
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer", "details");
   }
@@ -128,13 +128,13 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void testJoinOrder_when_fetchJoinsAndWhere_expect_fetchJoinsOnlyInFetchPaths() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status, orderDate")
       .fetch("details")
       .where().eq("customer.name", "rob").query();
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("details");
   }
@@ -142,13 +142,13 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void testJoinOrder_when_queryFetch_expect_getFetchPaths_doesNotIncludeQueryJoin() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status, orderDate")
       .fetch("customer", "name")
       .fetchQuery("details");
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer");
   }
@@ -156,13 +156,13 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void testJoinOrder_when_queryFetch_expect_getFetchPaths_doesNotIncludeQueryJoin_via_fetchQuery() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status, orderDate")
       .fetch("customer", "name")
       .fetchQuery("details");
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer");
   }
@@ -170,13 +170,13 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void testJoinOrder_when_lazyFetch_expect_getFetchPaths_doesNotIncludeQueryJoin() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status, orderDate")
       .fetch("customer", "name")
       .fetch("details", FetchConfig.ofLazy());
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer");
   }
@@ -184,13 +184,13 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void testJoinOrder_when_lazyFetch_expect_getFetchPaths_doesNotIncludeQueryJoin_via_fetchLazy() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status, orderDate")
       .fetch("customer", "name")
       .fetchLazy("details");
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer");
   }
@@ -198,14 +198,14 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void testJoinOrder_when_lazyFetchAndHasChildren_expect_getFetchPaths_doesNotIncludeJoinOrChild() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status, orderDate")
       .fetch("customer", "name")
       .fetchLazy("details")
       .fetch("details.product");
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer");
   }
@@ -213,14 +213,14 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void testJoinOrder_when_fetchMany_expect_getFetchPaths_containsAllInOrder() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status, orderDate")
       .fetch("details")
       .fetch("details.product")
       .fetch("customer", "name");
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("details", "details.product", "customer");
   }
@@ -228,14 +228,14 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void testJoinOrder_when_queryJoin_expect_getFetchPaths_excludesQueryJoinAndChildren() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status, orderDate")
       .fetchQuery("details")
       .fetch("details.product")
       .fetch("customer", "name");
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer");
   }
@@ -243,14 +243,14 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void test_removeJoinToMany_when_multipleManyPaths() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .fetch("details")
       .fetch("details.product")
       .fetch("customer")
       .fetch("customer.contacts"); // second many path
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("details", "details.product", "customer");
   }
@@ -258,7 +258,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void test_removeAllJoinToMany_when_firstRow() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .setFirstRow(1)
       .fetch("details") // many path
       .fetch("details.product")
@@ -266,7 +266,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
       .fetch("customer.contacts"); // many path
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer");
   }
@@ -274,7 +274,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void test_removeAllJoinToMany_when_maxRows() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .setMaxRows(1)
       .fetch("details") // many path
       .fetch("details.product")
@@ -282,7 +282,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
       .fetch("customer.contacts"); // many path
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer");
   }
@@ -290,7 +290,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void test_filterMany_included() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .fetch("details")
       .fetch("details.product")
       .fetch("customer")
@@ -299,7 +299,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
       .query();
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("details", "details.product", "customer");
   }
@@ -307,7 +307,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void test_filterMany_excludedByOrdering() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .fetch("customer")
       .fetch("customer.contacts")
       .fetch("details")
@@ -316,7 +316,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
       .query();
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer", "customer.contacts");
   }
@@ -324,7 +324,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
   @Test
   public void test_filterMany_excludedExplicitly() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .fetchQuery("details")
       .fetch("details.product")
       .fetch("customer")
@@ -333,7 +333,7 @@ public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
       .query();
 
     OrmQueryRequest<Order> queryRequest = queryRequest(query);
-    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+    OrmQueryDetail detail = queryRequest.query().getDetail();
 
     assertThat(detail.getFetchPaths()).containsExactly("customer", "customer.contacts");
   }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/DefaultServer_getReferenceTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/DefaultServer_getReferenceTest.java
similarity index 63%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/DefaultServer_getReferenceTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/DefaultServer_getReferenceTest.java
index 78cea8327..bbf2786b4 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/DefaultServer_getReferenceTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/DefaultServer_getReferenceTest.java
@@ -2,8 +2,8 @@ package io.ebeaninternal.server.core;
 
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Car;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
@@ -15,7 +15,7 @@ public class DefaultServer_getReferenceTest extends BaseTestCase {
 
   @Test
   public void getReference_noPC() {
-    Ebean.getReference(Customer.class, 42);
+    DB.reference(Customer.class, 42);
   }
 
   @Test
@@ -23,9 +23,9 @@ public class DefaultServer_getReferenceTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Ebean.execute(() -> {
-      Customer loaded = Ebean.find(Customer.class, 1);
-      Customer reference = Ebean.getReference(Customer.class, 1);
+    DB.execute(() -> {
+      Customer loaded = DB.find(Customer.class, 1);
+      Customer reference = DB.reference(Customer.class, 1);
       assertThat(loaded).isSameAs(reference);
     });
   }
@@ -36,14 +36,14 @@ public class DefaultServer_getReferenceTest extends BaseTestCase {
 
     Car car = new Car();
     car.setDriver("TestForRef");
-    Ebean.save(car);
+    DB.save(car);
 
-    Vehicle reference = Ebean.getReference(Vehicle.class, car.getId());
+    Vehicle reference = DB.reference(Vehicle.class, car.getId());
 
     assertThat(reference).isInstanceOf(Car.class);
     assertThat(reference.getId()).isSameAs(car.getId());
 
-    Ebean.delete(car);
+    DB.delete(car);
   }
 
 
@@ -52,14 +52,14 @@ public class DefaultServer_getReferenceTest extends BaseTestCase {
 
     Car car = new Car();
     car.setDriver("TestForRef");
-    Ebean.save(car);
+    DB.save(car);
 
-    Ebean.execute(() -> {
-        Vehicle loaded = Ebean.find(Vehicle.class, car.getId());
-        Vehicle reference = Ebean.getReference(Vehicle.class, car.getId());
+    DB.execute(() -> {
+        Vehicle loaded = DB.find(Vehicle.class, car.getId());
+        Vehicle reference = DB.reference(Vehicle.class, car.getId());
         assertThat(reference).isSameAs(loaded);
       }
     );
-    Ebean.delete(car);
+    DB.delete(car);
   }
 }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/DtoQueryRequestTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/DtoQueryRequestTest.java
similarity index 86%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/DtoQueryRequestTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/DtoQueryRequestTest.java
index 4b85f18f1..c78eafa93 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/DtoQueryRequestTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/DtoQueryRequestTest.java
@@ -1,9 +1,9 @@
 package io.ebeaninternal.server.core;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DtoQueryRequestTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/HelpCreateQueryRequest.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/HelpCreateQueryRequest.java
similarity index 67%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/HelpCreateQueryRequest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/HelpCreateQueryRequest.java
index 805ca2982..50863f117 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/HelpCreateQueryRequest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/HelpCreateQueryRequest.java
@@ -1,14 +1,13 @@
 package io.ebeaninternal.server.core;
 
-import io.ebean.EbeanServer;
+import io.ebean.Database;
 import io.ebean.Query;
 import io.ebean.Transaction;
 import io.ebeaninternal.api.SpiQuery;
 
 public class HelpCreateQueryRequest {
 
-  public static <T> OrmQueryRequest<T> create(EbeanServer server, SpiQuery.Type type, Query<T> query, Transaction t) {
-
+  public static <T> OrmQueryRequest<T> create(Database server, SpiQuery.Type type, Query<T> query, Transaction t) {
     DefaultServer defaultServer = (DefaultServer) server;
     return (OrmQueryRequest<T>)defaultServer.createQueryRequest(type, query, t);
   }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/InitDataSourceTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/InitDataSourceTest.java
similarity index 82%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/InitDataSourceTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/InitDataSourceTest.java
index 5065d17e5..584a943be 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/InitDataSourceTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/InitDataSourceTest.java
@@ -1,15 +1,15 @@
 package io.ebeaninternal.server.core;
 
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.datasource.DataSourceConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class InitDataSourceTest {
 
-  private ServerConfig newConfig(String readOnlyUrl) {
-    ServerConfig config = new ServerConfig();
+  private DatabaseConfig newConfig(String readOnlyUrl) {
+    DatabaseConfig config = new DatabaseConfig();
     DataSourceConfig roConfig = new DataSourceConfig();
     roConfig.setUrl(readOnlyUrl);
     config.setReadOnlyDataSourceConfig(roConfig);
@@ -18,13 +18,13 @@ public class InitDataSourceTest {
 
   @Test
   public void readOnlyConfig_nullByDefault() {
-    InitDataSource init = new InitDataSource(new ServerConfig());
+    InitDataSource init = new InitDataSource(new DatabaseConfig());
     assertNull(init.readOnlyConfig());
   }
 
   @Test
   public void readOnlyConfig_null_whenSetNullExplicitly() {
-    ServerConfig config = new ServerConfig();
+    DatabaseConfig config = new DatabaseConfig();
     config.setReadOnlyDataSourceConfig(null);
 
     assertNull(new InitDataSource(config).readOnlyConfig());
@@ -46,7 +46,7 @@ public class InitDataSourceTest {
 
   @Test
   public void readOnlyConfig_when_autoReadOnlyDataSource() {
-    ServerConfig config = new ServerConfig();
+    DatabaseConfig config = new DatabaseConfig();
     config.setAutoReadOnlyDataSource(true);
 
     assertNotNull(new InitDataSource(config).readOnlyConfig());
@@ -54,7 +54,7 @@ public class InitDataSourceTest {
 
   @Test
   public void readOnlyConfig_when_autoReadOnlyDataSource_expect_setToNull() {
-    ServerConfig config = newConfig("none");
+    DatabaseConfig config = newConfig("none");
     config.setAutoReadOnlyDataSource(true);
 
     final DataSourceConfig readOnlyConfig = new InitDataSource(config).readOnlyConfig();
@@ -63,7 +63,7 @@ public class InitDataSourceTest {
 
   @Test
   public void readOnlyConfig_when_urlSet() {
-    ServerConfig config = newConfig("foo");
+    DatabaseConfig config = newConfig("foo");
 
     final DataSourceConfig roConfig = new InitDataSource(config).readOnlyConfig();
     assertNotNull(roConfig);
@@ -72,7 +72,7 @@ public class InitDataSourceTest {
 
   @Test
   public void readOnlyConfig_when_readOnlyUrlSetOnMain() {
-    ServerConfig config = newConfig(null);
+    DatabaseConfig config = newConfig(null);
     // alternate location to set read-only url for developer convenience
     config.getDataSourceConfig().setReadOnlyUrl("bar");
 
@@ -83,7 +83,7 @@ public class InitDataSourceTest {
 
   @Test
   public void readOnlyConfig_when_readOnlyUrlSetOnMain_withNone() {
-    ServerConfig config = newConfig("None");
+    DatabaseConfig config = newConfig("None");
     // alternate location to set read-only url for developer convenience
     config.getDataSourceConfig().setReadOnlyUrl("bar");
 
@@ -94,7 +94,7 @@ public class InitDataSourceTest {
 
   @Test
   public void readOnlyConfig_when_bothReadOnlyUrlsSet() {
-    ServerConfig config = newConfig("one");
+    DatabaseConfig config = newConfig("one");
     config.getDataSourceConfig().setReadOnlyUrl("two");
 
     final DataSourceConfig roConfig = new InitDataSource(config).readOnlyConfig();
@@ -104,7 +104,7 @@ public class InitDataSourceTest {
 
   @Test
   public void readOnlyConfig_when_readOnlyUrlSetOnMain_withNoneNone() {
-    ServerConfig config = newConfig("none");
+    DatabaseConfig config = newConfig("none");
     // alternate location to set read-only url for developer convenience
     config.getDataSourceConfig().setReadOnlyUrl("none");
 
@@ -114,7 +114,7 @@ public class InitDataSourceTest {
 
   @Test
   public void readOnlyConfig_when_urlSet_2() {
-    ServerConfig config = new ServerConfig();
+    DatabaseConfig config = new DatabaseConfig();
     config.getReadOnlyDataSourceConfig().setUrl("foo");
 
     final DataSourceConfig roConfig = new InitDataSource(config).readOnlyConfig();
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/OrmQueryRequestTestHelper.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/OrmQueryRequestTestHelper.java
similarity index 79%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/OrmQueryRequestTestHelper.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/OrmQueryRequestTestHelper.java
index 88d21ea38..e0ab5e746 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/OrmQueryRequestTestHelper.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/OrmQueryRequestTestHelper.java
@@ -1,12 +1,12 @@
 package io.ebeaninternal.server.core;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebeaninternal.api.SpiQuery;
 
 public class OrmQueryRequestTestHelper {
 
-  static DefaultServer defaultServer = (DefaultServer) Ebean.getDefaultServer();
+  static DefaultServer defaultServer = (DefaultServer) DB.getDefault();
 
   /**
    * Create and return a OrmQueryRequest for the given query.
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/TestDiffHelpSimple.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/TestDiffHelpSimple.java
similarity index 60%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/TestDiffHelpSimple.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/TestDiffHelpSimple.java
index 5ab4b56ee..56be7e09c 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/TestDiffHelpSimple.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/TestDiffHelpSimple.java
@@ -1,41 +1,42 @@
 package io.ebeaninternal.server.core;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.ValuePair;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.Order.Status;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.sql.Date;
 import java.sql.Timestamp;
 import java.util.Map;
 import java.util.Set;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestDiffHelpSimple extends BaseTestCase {
 
   long firstTime = System.currentTimeMillis() - 10000;
   long secondTime = System.currentTimeMillis();
 
-  EbeanServer server;
+  Database server;
   BeanDescriptor<Order> orderDesc;
 
   public TestDiffHelpSimple() {
-    server = Ebean.getServer(null);
+    server = DB.getDefault();
     SpiEbeanServer spiServer = (SpiEbeanServer) server;
-    orderDesc = spiServer.getBeanDescriptor(Order.class);
+    orderDesc = spiServer.descriptor(Order.class);
   }
 
-  private Order createBaseOrder(EbeanServer server) {
+  private Order createBaseOrder(Database server) {
     Order order1 = new Order();
     order1.setId(12);
     order1.setCretime(new Timestamp(firstTime));
-    order1.setCustomer(server.getReference(Customer.class, 1234));
+    order1.setCustomer(server.reference(Customer.class, 1234));
     order1.setStatus(Status.NEW);
     order1.setShipDate(new Date(firstTime));
     order1.setOrderDate(new Date(firstTime));
@@ -51,21 +52,21 @@ public class TestDiffHelpSimple extends BaseTestCase {
     Order order2 = new Order();
     order2.setId(14);
     order2.setCretime(new Timestamp(secondTime));
-    order2.setCustomer(server.getReference(Customer.class, 2133));
+    order2.setCustomer(server.reference(Customer.class, 2133));
     order2.setStatus(Status.COMPLETE);
     order2.setShipDate(new Date(secondTime));
     order2.setOrderDate(new Date(secondTime));
 
     Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
 
-    Assert.assertEquals(5, diff.size());
+    assertEquals(5, diff.size());
 
     Set<String> keySet = diff.keySet();
-    Assert.assertTrue(keySet.contains("cretime"));
-    Assert.assertTrue(keySet.contains("status"));
-    Assert.assertTrue(keySet.contains("shipDate"));
-    Assert.assertTrue(keySet.contains("orderDate"));
-    Assert.assertTrue(keySet.contains("customer.id"));
+    assertTrue(keySet.contains("cretime"));
+    assertTrue(keySet.contains("status"));
+    assertTrue(keySet.contains("shipDate"));
+    assertTrue(keySet.contains("orderDate"));
+    assertTrue(keySet.contains("customer.id"));
   }
 
   @Test
@@ -77,23 +78,23 @@ public class TestDiffHelpSimple extends BaseTestCase {
     Order order2 = new Order();
     order2.setId(14);
     order2.setCretime(new Timestamp(secondTime));
-    order2.setCustomer(server.getReference(Customer.class, 2133));
+    order2.setCustomer(server.reference(Customer.class, 2133));
     order2.setStatus(Status.COMPLETE);
     order2.setShipDate(new Date(secondTime));
     order2.setOrderDate(new Date(secondTime));
 
     Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
 
-    Assert.assertEquals(5, diff.size());
+    assertEquals(5, diff.size());
 
     Set<String> keySet = diff.keySet();
-    Assert.assertTrue(keySet.contains("cretime"));
-    Assert.assertTrue(keySet.contains("status"));
-    Assert.assertTrue(keySet.contains("shipDate"));
-    Assert.assertTrue(keySet.contains("orderDate"));
-    Assert.assertTrue(keySet.contains("customer.id"));
-    Assert.assertEquals(2133, diff.get("customer.id").getOldValue());
-    Assert.assertEquals(1234, diff.get("customer.id").getNewValue());
+    assertTrue(keySet.contains("cretime"));
+    assertTrue(keySet.contains("status"));
+    assertTrue(keySet.contains("shipDate"));
+    assertTrue(keySet.contains("orderDate"));
+    assertTrue(keySet.contains("customer.id"));
+    assertEquals(2133, diff.get("customer.id").getOldValue());
+    assertEquals(1234, diff.get("customer.id").getNewValue());
   }
 
   @Test
@@ -105,7 +106,7 @@ public class TestDiffHelpSimple extends BaseTestCase {
 
     Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
 
-    Assert.assertEquals(0, diff.size());
+    assertEquals(0, diff.size());
   }
 
   @Test
@@ -114,23 +115,23 @@ public class TestDiffHelpSimple extends BaseTestCase {
     Order order1 = createBaseOrder(server);
 
     Order order2 = createBaseOrder(server);
-    order2.setCustomer(server.getReference(Customer.class, 2133));
+    order2.setCustomer(server.reference(Customer.class, 2133));
     order2.setStatus(Status.COMPLETE);
     order2.setShipDate(null);
 
     Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
 
-    Assert.assertEquals(3, diff.size());
+    assertEquals(3, diff.size());
 
     Set<String> keySet = diff.keySet();
-    Assert.assertTrue(keySet.contains("status"));
-    Assert.assertTrue(keySet.contains("customer.id"));
-    Assert.assertTrue(keySet.contains("shipDate"));
+    assertTrue(keySet.contains("status"));
+    assertTrue(keySet.contains("customer.id"));
+    assertTrue(keySet.contains("shipDate"));
 
     ValuePair shipDatePair = diff.get("shipDate");
-    Assert.assertEquals(order1.getShipDate(), shipDatePair.getNewValue());
-    Assert.assertEquals(order2.getShipDate(), shipDatePair.getOldValue());
-    Assert.assertNull(shipDatePair.getOldValue());
+    assertEquals(order1.getShipDate(), shipDatePair.getNewValue());
+    assertEquals(order2.getShipDate(), shipDatePair.getOldValue());
+    assertNull(shipDatePair.getOldValue());
   }
 
 
@@ -145,14 +146,14 @@ public class TestDiffHelpSimple extends BaseTestCase {
 
     Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
 
-    Assert.assertEquals(1, diff.size());
+    assertEquals(1, diff.size());
     Set<String> keySet = diff.keySet();
-    Assert.assertTrue(keySet.contains("shipDate"));
+    assertTrue(keySet.contains("shipDate"));
 
     ValuePair shipDatePair = diff.get("shipDate");
-    Assert.assertEquals(order1.getShipDate(), shipDatePair.getNewValue());
-    Assert.assertEquals(order2.getShipDate(), shipDatePair.getOldValue());
-    Assert.assertNull(shipDatePair.getNewValue());
+    assertEquals(order1.getShipDate(), shipDatePair.getNewValue());
+    assertEquals(order2.getShipDate(), shipDatePair.getOldValue());
+    assertNull(shipDatePair.getNewValue());
   }
 
   @Test
@@ -166,6 +167,6 @@ public class TestDiffHelpSimple extends BaseTestCase {
 
     Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
 
-    Assert.assertEquals(0, diff.size());
+    assertEquals(0, diff.size());
   }
 }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/TestDiffHelpWithEmbedded.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/TestDiffHelpWithEmbedded.java
similarity index 67%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/TestDiffHelpWithEmbedded.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/TestDiffHelpWithEmbedded.java
index 9162609d9..6b3371bfb 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/TestDiffHelpWithEmbedded.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/TestDiffHelpWithEmbedded.java
@@ -1,28 +1,29 @@
 package io.ebeaninternal.server.core;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.ValuePair;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.junit.jupiter.api.Test;
 import org.tests.model.embedded.EMain;
 import org.tests.model.embedded.Eembeddable;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.Map;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestDiffHelpWithEmbedded extends BaseTestCase {
 
-  EbeanServer server;
+  Database server;
 
   BeanDescriptor<EMain> emainDesc;
 
   public TestDiffHelpWithEmbedded() {
-    server = Ebean.getServer(null);
+    server = DB.getDefault();
     SpiEbeanServer spiServer = (SpiEbeanServer) server;
-    emainDesc = spiServer.getBeanDescriptor(EMain.class);
+    emainDesc = spiServer.descriptor(EMain.class);
   }
 
   @Test
@@ -34,12 +35,12 @@ public class TestDiffHelpWithEmbedded extends BaseTestCase {
     emain2.getEmbeddable().setDescription("baz");
 
     Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
-    Assert.assertEquals(1, diff.size());
+    assertEquals(1, diff.size());
     ValuePair valuePair = diff.get("embeddable.description");
 
-    Assert.assertNotNull(valuePair);
-    Assert.assertEquals("bar", valuePair.getNewValue());
-    Assert.assertEquals("baz", valuePair.getOldValue());
+    assertNotNull(valuePair);
+    assertEquals("bar", valuePair.getNewValue());
+    assertEquals("baz", valuePair.getOldValue());
   }
 
   /**
@@ -57,12 +58,12 @@ public class TestDiffHelpWithEmbedded extends BaseTestCase {
 
 
     Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
-    Assert.assertEquals(1, diff.size());
+    assertEquals(1, diff.size());
     ValuePair valuePair = diff.get("embeddable.description");
 
-    Assert.assertNotNull(valuePair);
-    Assert.assertEquals("bar", valuePair.getNewValue());
-    Assert.assertEquals("baz", valuePair.getOldValue());
+    assertNotNull(valuePair);
+    assertEquals("bar", valuePair.getNewValue());
+    assertEquals("baz", valuePair.getOldValue());
   }
 
   @Test
@@ -73,12 +74,12 @@ public class TestDiffHelpWithEmbedded extends BaseTestCase {
     emain2.getEmbeddable().setDescription("baz");
 
     Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
-    Assert.assertEquals(1, diff.size());
+    assertEquals(1, diff.size());
     ValuePair valuePair = diff.get("embeddable.description");
 
-    Assert.assertNotNull(valuePair);
-    Assert.assertEquals("bar", valuePair.getNewValue());
-    Assert.assertEquals("baz", valuePair.getOldValue());
+    assertNotNull(valuePair);
+    assertEquals("bar", valuePair.getNewValue());
+    assertEquals("baz", valuePair.getOldValue());
   }
 
   @Test
@@ -89,12 +90,12 @@ public class TestDiffHelpWithEmbedded extends BaseTestCase {
     EMain emain2 = createEMain();
 
     Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
-    Assert.assertEquals(1, diff.size());
+    assertEquals(1, diff.size());
     ValuePair valuePair = diff.get("embeddable.description");
 
-    Assert.assertNotNull(valuePair);
-    Assert.assertNull(valuePair.getNewValue());
-    Assert.assertEquals("bar", valuePair.getOldValue());
+    assertNotNull(valuePair);
+    assertNull(valuePair.getNewValue());
+    assertEquals("bar", valuePair.getOldValue());
   }
 
   @Test
@@ -105,12 +106,12 @@ public class TestDiffHelpWithEmbedded extends BaseTestCase {
     emain2.setEmbeddable(null);
 
     Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
-    Assert.assertEquals(1, diff.size());
+    assertEquals(1, diff.size());
     ValuePair valuePair = diff.get("embeddable.description");
 
-    Assert.assertNotNull(valuePair);
-    Assert.assertNull(valuePair.getOldValue());
-    Assert.assertEquals("bar", valuePair.getNewValue());
+    assertNotNull(valuePair);
+    assertNull(valuePair.getOldValue());
+    assertEquals("bar", valuePair.getNewValue());
   }
 
   @Test
@@ -121,12 +122,12 @@ public class TestDiffHelpWithEmbedded extends BaseTestCase {
     emain2.setEmbeddable(null);
 
     Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
-    Assert.assertEquals(1, diff.size());
+    assertEquals(1, diff.size());
     ValuePair valuePair = diff.get("embeddable.description");
 
-    Assert.assertNotNull(valuePair);
-    Assert.assertNull(valuePair.getOldValue());
-    Assert.assertEquals("bar", valuePair.getNewValue());
+    assertNotNull(valuePair);
+    assertNull(valuePair.getOldValue());
+    assertEquals("bar", valuePair.getNewValue());
   }
 
   @Test
@@ -138,19 +139,17 @@ public class TestDiffHelpWithEmbedded extends BaseTestCase {
     emain2.setEmbeddable(null);
 
     Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
-    Assert.assertEquals(0, diff.size());
+    assertEquals(0, diff.size());
   }
 
   private EMain createEMain() {
-
     EMain emain = new EMain();
     emain.setName("foo");
-    emain.setVersion(13l);
+    emain.setVersion(13L);
 
     Eembeddable embeddable = new Eembeddable();
     embeddable.setDescription("bar");
     emain.setEmbeddable(embeddable);
-
     return emain;
   }
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/bootup/DistillPackagesTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/bootup/DistillPackagesTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/bootup/DistillPackagesTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/bootup/DistillPackagesTest.java
index 615d0433f..3484ac968 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/bootup/DistillPackagesTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/bootup/DistillPackagesTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.core.bootup;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 import java.util.List;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/core/bootup/ManifestReaderTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/core/bootup/ManifestReaderTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/core/bootup/ManifestReaderTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/core/bootup/ManifestReaderTest.java
index 4f1063c7d..0bb79f2ae 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/core/bootup/ManifestReaderTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/core/bootup/ManifestReaderTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.core.bootup;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Set;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanCascadeInfoTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanCascadeInfoTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanCascadeInfoTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanCascadeInfoTest.java
index 3a0527381..190588605 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanCascadeInfoTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanCascadeInfoTest.java
@@ -1,11 +1,11 @@
 package io.ebeaninternal.server.deploy;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import javax.persistence.CascadeType;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class BeanCascadeInfoTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptorTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptorTest.java
similarity index 82%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptorTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptorTest.java
index ab8ae6a87..382397c9b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptorTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptorTest.java
@@ -1,14 +1,14 @@
 package io.ebeaninternal.server.deploy;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.EntityBean;
 import io.ebean.plugin.Property;
 import io.ebeaninternal.server.core.CacheOptions;
 import io.ebeaninternal.server.deploy.meta.DeployBeanDescriptor;
 import io.ebeaninternal.server.deploy.meta.DeployIdentityMode;
 import io.ebeanservice.docstore.api.DocStoreBeanAdapter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.*;
 import org.tests.model.bridge.BSite;
 import org.tests.model.bridge.BUser;
@@ -16,65 +16,65 @@ import org.tests.model.bridge.BUser;
 import java.util.Collection;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 public class BeanDescriptorTest extends BaseTestCase {
 
-  private BeanDescriptor<Customer> customerDesc = spiEbeanServer().getBeanDescriptor(Customer.class);
+  private BeanDescriptor<Customer> customerDesc = spiEbeanServer().descriptor(Customer.class);
 
   @Test
   public void createReference() {
 
     Customer bean = customerDesc.createReference(null, false, 42, null);
     assertThat(bean.getId()).isEqualTo(42);
-    assertThat(server().getBeanState(bean).isReadOnly()).isFalse();
+    assertThat(server().beanState(bean).isReadOnly()).isFalse();
   }
 
   @Test
   public void createReference_whenReadOnly() {
 
     Customer bean = customerDesc.createReference(Boolean.TRUE, false, 42, null);
-    assertThat(server().getBeanState(bean).isReadOnly()).isTrue();
+    assertThat(server().beanState(bean).isReadOnly()).isTrue();
   }
 
   @Test
   public void createReference_whenNotReadOnly() {
 
     Customer bean = customerDesc.createReference(Boolean.FALSE, false, 42, null);
-    assertThat(server().getBeanState(bean).isReadOnly()).isFalse();
+    assertThat(server().beanState(bean).isReadOnly()).isFalse();
 
     bean = customerDesc.createReference(42, null);
-    assertThat(server().getBeanState(bean).isReadOnly()).isFalse();
+    assertThat(server().beanState(bean).isReadOnly()).isFalse();
   }
 
   @Test
   public void createReference_when_disabledLazyLoad() {
 
     Customer bean = customerDesc.createReference(Boolean.FALSE, true, 42, null);
-    assertThat(server().getBeanState(bean).isDisableLazyLoad()).isTrue();
+    assertThat(server().beanState(bean).isDisableLazyLoad()).isTrue();
   }
 
   @Test
   public void createReference_with_inheritance() {
     Cat cat = new Cat();
     cat.setName("Puss");
-    Ebean.save(cat);
+    DB.save(cat);
 
     Dog dog = new Dog();
     dog.setRegistrationNumber("DOGGIE");
-    Ebean.save(dog);
+    DB.save(dog);
 
     AnimalShelter shelter = new AnimalShelter();
     shelter.setName("My Animal Shelter");
     shelter.getAnimals().add(cat);
     shelter.getAnimals().add(dog);
 
-    Ebean.save(shelter);
+    DB.save(shelter);
 
-    BeanDescriptor<Animal> animalDesc = spiEbeanServer().getBeanDescriptor(Animal.class);
+    BeanDescriptor<Animal> animalDesc = spiEbeanServer().descriptor(Animal.class);
 
     Animal bean = animalDesc.createReference(Boolean.FALSE, false, dog.getId(), null);
     assertThat(bean.getId()).isEqualTo(dog.getId());
@@ -142,7 +142,7 @@ public class BeanDescriptorTest extends BaseTestCase {
   @Test
   public void isIdTypeExternal_when_externalId() {
 
-    BeanDescriptor<Country> countryDesc = spiEbeanServer().getBeanDescriptor(Country.class);
+    BeanDescriptor<Country> countryDesc = spiEbeanServer().descriptor(Country.class);
     assertThat(countryDesc.isIdGeneratedValue()).isFalse();
   }
 
@@ -155,21 +155,21 @@ public class BeanDescriptorTest extends BaseTestCase {
   @Test
   public void isIdTypeExternal_when_explicitGeneratedValue() {
 
-    BeanDescriptor<Contact> desc = spiEbeanServer().getBeanDescriptor(Contact.class);
+    BeanDescriptor<Contact> desc = spiEbeanServer().descriptor(Contact.class);
     assertThat(desc.isIdGeneratedValue()).isTrue();
   }
 
   @Test
   public void isIdTypeExternal_when_uuidGenerator_and_generatedValue() {
 
-    BeanDescriptor<BSite> desc = spiEbeanServer().getBeanDescriptor(BSite.class);
+    BeanDescriptor<BSite> desc = spiEbeanServer().descriptor(BSite.class);
     assertThat(desc.isIdGeneratedValue()).isTrue();
   }
 
   @Test
   public void isIdTypeExternal_when_uuidGenerator_and_noGeneratedValue() {
 
-    BeanDescriptor<BUser> desc = spiEbeanServer().getBeanDescriptor(BUser.class);
+    BeanDescriptor<BUser> desc = spiEbeanServer().descriptor(BUser.class);
     assertThat(desc.isIdGeneratedValue()).isFalse();
   }
 }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_documentMappingTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_documentMappingTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_documentMappingTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_documentMappingTest.java
index b2ddea188..063a7a515 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_documentMappingTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_documentMappingTest.java
@@ -4,8 +4,8 @@ import io.ebean.BaseTestCase;
 import io.ebeanservice.docstore.api.mapping.DocPropertyAdapter;
 import io.ebeanservice.docstore.api.mapping.DocPropertyMapping;
 import io.ebeanservice.docstore.api.mapping.DocumentMapping;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -17,7 +17,7 @@ public class BeanDescriptor_documentMappingTest extends BaseTestCase {
 
     BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
 
-    DocumentMapping documentMapping = desc.getDocMapping();
+    DocumentMapping documentMapping = desc.docMapping();
 
     DocPropertyMapping properties = documentMapping.getProperties();
 
@@ -29,7 +29,7 @@ public class BeanDescriptor_documentMappingTest extends BaseTestCase {
 
     BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
 
-    DocumentMapping documentMapping = desc.getDocMapping();
+    DocumentMapping documentMapping = desc.docMapping();
 
     DocPropertyMapping properties = documentMapping.getProperties();
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_registerTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_registerTest.java
similarity index 74%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_registerTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_registerTest.java
index 31721e893..13a25e08a 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_registerTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_registerTest.java
@@ -6,10 +6,10 @@ import io.ebean.event.AbstractBeanPersistListener;
 import io.ebean.event.BeanPersistAdapter;
 import io.ebean.event.BeanPersistListener;
 import io.ebeaninternal.api.SpiEbeanServer;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
-import org.junit.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class BeanDescriptor_registerTest {
 
@@ -27,7 +27,7 @@ public class BeanDescriptor_registerTest {
 
     SpiEbeanServer ebeanServer = (SpiEbeanServer)DatabaseFactory.create(config);
     try {
-      BeanDescriptor<EBasic> desc = ebeanServer.getBeanDescriptor(EBasic.class);
+      BeanDescriptor<EBasic> desc = ebeanServer.descriptor(EBasic.class);
       persistListenerRegistrationTests(desc);
       persistControllerRegistrationTests(desc);
     } finally {
@@ -39,42 +39,42 @@ public class BeanDescriptor_registerTest {
 
     Controller1 controller1 = new Controller1();
 
-    assertNull(desc.getPersistController());
+    assertNull(desc.persistController());
     desc.register(controller1);
-    assertSame(controller1, desc.getPersistController());
+    assertSame(controller1, desc.persistController());
 
     Controller2 controller2 = new Controller2();
     desc.register(controller2);
 
-    assertEquals(2, ((ChainedBeanPersistController) desc.getPersistController()).size());
+    assertEquals(2, ((ChainedBeanPersistController) desc.persistController()).size());
 
     desc.deregister(controller1);
-    assertEquals(1, ((ChainedBeanPersistController) desc.getPersistController()).size());
+    assertEquals(1, ((ChainedBeanPersistController) desc.persistController()).size());
 
     desc.deregister(controller2);
-    assertEquals(0, ((ChainedBeanPersistController) desc.getPersistController()).size());
+    assertEquals(0, ((ChainedBeanPersistController) desc.persistController()).size());
   }
 
   private void persistListenerRegistrationTests(BeanDescriptor<EBasic> desc) {
 
     Listener1 listener1 = new Listener1();
 
-    assertNull(desc.getPersistListener());
+    assertNull(desc.persistListener());
     desc.register(listener1);
-    assertSame(listener1, desc.getPersistListener());
+    assertSame(listener1, desc.persistListener());
 
     Listener2 listener2 = new Listener2();
     desc.register(listener2);
 
-    BeanPersistListener persistListener = desc.getPersistListener();
+    BeanPersistListener persistListener = desc.persistListener();
     assertTrue(persistListener instanceof ChainedBeanPersistListener);
     assertEquals(2, ((ChainedBeanPersistListener) persistListener).size());
 
     desc.deregister(listener1);
-    assertEquals(1, ((ChainedBeanPersistListener) desc.getPersistListener()).size());
+    assertEquals(1, ((ChainedBeanPersistListener) desc.persistListener()).size());
 
     desc.deregister(listener2);
-    assertEquals(0, ((ChainedBeanPersistListener) desc.getPersistListener()).size());
+    assertEquals(0, ((ChainedBeanPersistListener) desc.persistListener()).size());
   }
 
   public static class Listener1 extends AbstractBeanPersistListener {
diff --git a/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_whenCreatedPropertyTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_whenCreatedPropertyTest.java
new file mode 100644
index 000000000..3407b37be
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_whenCreatedPropertyTest.java
@@ -0,0 +1,35 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.EBasic;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+
+public class BeanDescriptor_whenCreatedPropertyTest extends BaseTestCase {
+
+
+  @Test
+  public void test() {
+
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
+
+    BeanDescriptor<Customer> desc = server.descriptor(Customer.class);
+
+    BeanProperty whenCreatedProperty = desc.whenCreatedProperty();
+    assertEquals("cretime", whenCreatedProperty.dbColumn());
+
+    BeanProperty whenModifiedProperty = desc.whenModifiedProperty();
+    assertEquals("updtime", whenModifiedProperty.dbColumn());
+
+
+    BeanDescriptor<EBasic> eBasicDesc = server.descriptor(EBasic.class);
+    assertNull(eBasicDesc.whenCreatedProperty());
+    assertNull(eBasicDesc.whenModifiedProperty());
+  }
+}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanIudMetricsTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanIudMetricsTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanIudMetricsTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanIudMetricsTest.java
index 9f26e978c..92f2269f3 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanIudMetricsTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanIudMetricsTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.server.deploy;
 import io.ebean.meta.BasicMetricVisitor;
 import io.ebean.meta.MetaTimedMetric;
 import io.ebeaninternal.server.core.PersistRequest;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyTest.java
index ff35bf77e..c63966f21 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyTest.java
@@ -4,7 +4,7 @@ import io.ebean.BaseTestCase;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebean.common.BeanList;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
@@ -13,18 +13,16 @@ import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 
 public class BeanPropertyAssocManyTest extends BaseTestCase {
 
-  private BeanDescriptor<Customer> customerDesc = spiEbeanServer().getBeanDescriptor(Customer.class);
+  private BeanDescriptor<Customer> customerDesc = spiEbeanServer().descriptor(Customer.class);
 
   @SuppressWarnings("unchecked")
   private BeanPropertyAssocMany<Customer> contacts() {
-    return (BeanPropertyAssocMany<Customer>) customerDesc.getBeanProperty("contacts");
+    return (BeanPropertyAssocMany<Customer>) customerDesc.beanProperty("contacts");
   }
 
   @Test
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserMapTests.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserMapTests.java
similarity index 72%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserMapTests.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserMapTests.java
index 5f4080163..0a4f45f90 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserMapTests.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserMapTests.java
@@ -1,11 +1,12 @@
 package io.ebeaninternal.server.deploy;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.HashMap;
 import java.util.Map;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class DeployPropertyParserMapTests {
 
   @Test
@@ -19,7 +20,7 @@ public class DeployPropertyParserMapTests {
     DeployPropertyParserMap parser = new DeployPropertyParserMap(map);
 
     String output = parser.parse("(lower(customer.name) like ? escape'' or id > ?)");
-    Assert.assertEquals("(lower(t1.name) like ? escape'' or t0.id > ?)", output);
+    assertEquals("(lower(t1.name) like ? escape'' or t0.id > ?)", output);
   }
 
 }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserTest.java
index cfb35f740..4ca2a3681 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.server.deploy;
 import io.ebean.BaseTestCase;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.BWithQIdent;
 import org.tests.model.basic.Customer;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/DetermineAggPathTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/DetermineAggPathTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/DetermineAggPathTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/DetermineAggPathTest.java
index 5330d3ab6..c1e4d32ff 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/DetermineAggPathTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/DetermineAggPathTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.deploy;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/FormulaPropertyPathTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/FormulaPropertyPathTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/FormulaPropertyPathTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/FormulaPropertyPathTest.java
index 681e82bf1..71b888046 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/FormulaPropertyPathTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/FormulaPropertyPathTest.java
@@ -1,8 +1,7 @@
 package io.ebeaninternal.server.deploy;
 
 import io.ebean.BaseTestCase;
-import io.ebeaninternal.server.query.STreeProperty;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/IndexDefinitionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/IndexDefinitionTest.java
similarity index 90%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/IndexDefinitionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/IndexDefinitionTest.java
index cf206edaf..aadc88109 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/IndexDefinitionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/IndexDefinitionTest.java
@@ -1,8 +1,9 @@
 package io.ebeaninternal.server.deploy;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class IndexDefinitionTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TableJoinColumnTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TableJoinColumnTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/TableJoinColumnTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/TableJoinColumnTest.java
index 770aba39f..9a4143f6b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TableJoinColumnTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TableJoinColumnTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.deploy;
 
 import io.ebeaninternal.server.deploy.meta.DeployTableJoinColumn;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TableJoinTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TableJoinTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/TableJoinTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/TableJoinTest.java
index e29f58dd8..cba2035d0 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TableJoinTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TableJoinTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.server.deploy;
 
 import io.ebeaninternal.server.deploy.meta.DeployTableJoin;
 import io.ebeaninternal.server.deploy.meta.DeployTableJoinColumn;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestBeanDescriptorHasIdProperty.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestBeanDescriptorHasIdProperty.java
similarity index 75%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestBeanDescriptorHasIdProperty.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestBeanDescriptorHasIdProperty.java
index 815ba9888..112fcf345 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestBeanDescriptorHasIdProperty.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestBeanDescriptorHasIdProperty.java
@@ -1,42 +1,42 @@
 package io.ebeaninternal.server.deploy;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
 import io.ebeaninternal.api.SpiEbeanServer;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.composite.RCustomer;
 import org.tests.model.composite.RCustomerKey;
-import org.junit.Test;
 import org.tests.model.embedded.UserInterestLive;
 import org.tests.model.embedded.UserInterestLiveKey;
 
 import java.sql.Timestamp;
 import java.util.Map;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestBeanDescriptorHasIdProperty extends BaseTestCase {
 
   SpiEbeanServer spiServer;
 
   public TestBeanDescriptorHasIdProperty() {
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
     spiServer = (SpiEbeanServer) server;
   }
 
   @Test
   public void testHasId() {
 
-    BeanDescriptor<Order> beanDescriptor = spiServer.getBeanDescriptor(Order.class);
-    assertNotNull(beanDescriptor.getIdProperty());
-    assertEquals("id", beanDescriptor.getIdProperty().getName());
+    BeanDescriptor<Order> beanDescriptor = spiServer.descriptor(Order.class);
+    assertNotNull(beanDescriptor.idProperty());
+    assertEquals("id", beanDescriptor.idProperty().name());
 
-    assertNotNull(beanDescriptor.getVersionProperty());
-    assertEquals("updtime", beanDescriptor.getVersionProperty().getName());
+    assertNotNull(beanDescriptor.versionProperty());
+    assertEquals("updtime", beanDescriptor.versionProperty().name());
 
     Order order = new Order();
 
@@ -54,7 +54,7 @@ public class TestBeanDescriptorHasIdProperty extends BaseTestCase {
   @Test
   public void testIsReference() {
 
-    BeanDescriptor<Customer> beanDescriptor = spiServer.getBeanDescriptor(Customer.class);
+    BeanDescriptor<Customer> beanDescriptor = spiServer.descriptor(Customer.class);
 
     Customer order = new Customer();
     EntityBeanIntercept ebi = getIntercept(order);
@@ -69,7 +69,7 @@ public class TestBeanDescriptorHasIdProperty extends BaseTestCase {
 
   @Test
   public void isReference_withGeneratedOnInsertOnlyProperty_expect_false() {
-    BeanDescriptor<UserInterestLive> descriptor = spiServer.getBeanDescriptor(UserInterestLive.class);
+    BeanDescriptor<UserInterestLive> descriptor = spiServer.descriptor(UserInterestLive.class);
     UserInterestLive bean = new UserInterestLive(new UserInterestLiveKey(1L, 2L));
     EntityBeanIntercept ebi = getIntercept(bean);
     assertFalse(descriptor.referenceIdPropertyOnly(ebi));
@@ -78,11 +78,11 @@ public class TestBeanDescriptorHasIdProperty extends BaseTestCase {
   @Test
   public void test_getIdForJson() {
 
-    BeanDescriptor<Order> orderDesc = spiServer.getBeanDescriptor(Order.class);
+    BeanDescriptor<Order> orderDesc = spiServer.descriptor(Order.class);
 
     Order order = new Order();
     order.setId(42);
-    assertEquals(42, orderDesc.getIdForJson(order));
+    assertEquals(42, orderDesc.idForJson(order));
 
     assertEquals(42, orderDesc.convertIdFromJson(42));
     assertEquals(42, orderDesc.convertIdFromJson("42"));
@@ -96,10 +96,10 @@ public class TestBeanDescriptorHasIdProperty extends BaseTestCase {
     RCustomer rCustomer = new RCustomer();
     rCustomer.setKey(key);
 
-    BeanDescriptor<RCustomer> rcustDesc = spiServer.getBeanDescriptor(RCustomer.class);
+    BeanDescriptor<RCustomer> rcustDesc = spiServer.descriptor(RCustomer.class);
 
     @SuppressWarnings("unchecked")
-    Map<String, Object> idForJson = (Map<String, Object>) rcustDesc.getIdForJson(rCustomer);
+    Map<String, Object> idForJson = (Map<String, Object>) rcustDesc.idForJson(rCustomer);
     assertEquals("comp", idForJson.get("company"));
     assertEquals("fred", idForJson.get("name"));
     assertEquals(2, idForJson.size());
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestCollectionLoadedStatus.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestCollectionLoadedStatus.java
similarity index 50%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestCollectionLoadedStatus.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestCollectionLoadedStatus.java
index 611c20fef..406dbd2ef 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestCollectionLoadedStatus.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestCollectionLoadedStatus.java
@@ -1,41 +1,42 @@
 package io.ebeaninternal.server.deploy;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
 import io.ebeaninternal.api.SpiEbeanServer;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestCollectionLoadedStatus extends BaseTestCase {
 
   @Test
   public void test() {
 
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
-    BeanDescriptor<Customer> custDesc = server.getBeanDescriptor(Customer.class);
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
+    BeanDescriptor<Customer> custDesc = server.descriptor(Customer.class);
 
     Customer customer = new Customer();
     EntityBean eb = (EntityBean) customer;
     EntityBeanIntercept ebi = eb._ebean_getIntercept();
 
-    BeanProperty contactsProperty = custDesc.getBeanProperty("contacts");
-    Assert.assertFalse(ebi.isLoadedProperty(contactsProperty.getPropertyIndex()));
+    BeanProperty contactsProperty = custDesc.beanProperty("contacts");
+    assertFalse(ebi.isLoadedProperty(contactsProperty.propertyIndex()));
 
     Object contactsViaInternal = contactsProperty.getValue(eb);
-    Assert.assertNull(contactsViaInternal);
-    Assert.assertFalse(ebi.isLoadedProperty(contactsProperty.getPropertyIndex()));
+    assertNull(contactsViaInternal);
+    assertFalse(ebi.isLoadedProperty(contactsProperty.propertyIndex()));
 
     List<Contact> contacts = customer.getContacts();
-    Assert.assertNotNull(contacts);
-    Assert.assertTrue(contacts instanceof BeanCollection);
-    Assert.assertTrue(ebi.isLoadedProperty(contactsProperty.getPropertyIndex()));
+    assertNotNull(contacts);
+    assertTrue(contacts instanceof BeanCollection);
+    assertTrue(ebi.isLoadedProperty(contactsProperty.propertyIndex()));
   }
 
 }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertSimple.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertSimple.java
similarity index 77%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertSimple.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertSimple.java
index 4e7704a02..6ad4e5ba0 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertSimple.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertSimple.java
@@ -1,12 +1,12 @@
 package io.ebeaninternal.server.deploy;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.bean.EntityBean;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.json.SpiJsonWriter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.Order.Status;
@@ -21,23 +21,23 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestDiffHelpInsertSimple extends BaseTestCase {
 
-  private long firstTime = System.currentTimeMillis() - 10000;
+  private final long firstTime = System.currentTimeMillis() - 10000;
 
-  private EbeanServer server;
+  private final Database server;
 
-  private BeanDescriptor<Order> orderDesc;
+  private final BeanDescriptor<Order> orderDesc;
 
   public TestDiffHelpInsertSimple() {
-    server = Ebean.getServer(null);
+    server = DB.getDefault();
     SpiEbeanServer spiServer = (SpiEbeanServer) server;
-    orderDesc = spiServer.getBeanDescriptor(Order.class);
+    orderDesc = spiServer.descriptor(Order.class);
   }
 
-  private Order createBaseOrder(EbeanServer server) {
+  private Order createBaseOrder(Database server) {
     Order order1 = new Order();
     order1.setId(12);
     order1.setCretime(new Timestamp(firstTime));
-    order1.setCustomer(server.getReference(Customer.class, 1234));
+    order1.setCustomer(server.reference(Customer.class, 1234));
     order1.setStatus(Status.NEW);
     //order1.setShipDate(new Date(firstTime));
     order1.setOrderDate(new Date(firstTime));
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertWithEmbedded.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertWithEmbedded.java
similarity index 89%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertWithEmbedded.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertWithEmbedded.java
index f2a03c63d..f835cc427 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertWithEmbedded.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestDiffHelpInsertWithEmbedded.java
@@ -1,12 +1,12 @@
 package io.ebeaninternal.server.deploy;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.bean.EntityBean;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.json.SpiJsonWriter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.embedded.EMain;
 import org.tests.model.embedded.Eembeddable;
 
@@ -17,14 +17,12 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestDiffHelpInsertWithEmbedded extends BaseTestCase {
 
-  private EbeanServer server;
-
-  private BeanDescriptor<EMain> emainDesc;
+  private final BeanDescriptor<EMain> emainDesc;
 
   public TestDiffHelpInsertWithEmbedded() {
-    server = Ebean.getServer(null);
+    Database server = DB.getDefault();
     SpiEbeanServer spiServer = (SpiEbeanServer) server;
-    emainDesc = spiServer.getBeanDescriptor(EMain.class);
+    emainDesc = spiServer.descriptor(EMain.class);
   }
 
   @Test
@@ -84,15 +82,13 @@ public class TestDiffHelpInsertWithEmbedded extends BaseTestCase {
   }
 
   private EMain createEMain() {
-
     EMain emain = new EMain();
     emain.setName("foo");
-    emain.setVersion(13l);
+    emain.setVersion(13L);
 
     Eembeddable embeddable = new Eembeddable();
     embeddable.setDescription("bar");
     emain.setEmbeddable(embeddable);
-
     return emain;
   }
 
diff --git a/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestNotEnhancedMappedSuper.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestNotEnhancedMappedSuper.java
new file mode 100644
index 000000000..b2d302848
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestNotEnhancedMappedSuper.java
@@ -0,0 +1,39 @@
+package io.ebeaninternal.server.deploy;
+
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.bean.EntityBean;
+import org.junit.jupiter.api.Test;
+import org.tests.model.mappedsuper.ASimpleBean;
+import org.tests.model.mappedsuper.NotEnhancedMappedSuper;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestNotEnhancedMappedSuper extends BaseTestCase {
+
+  @Test
+  public void simpleBean_mappedSuperNotEnhanced_ok() {
+
+    ASimpleBean bean = new ASimpleBean();
+    bean.setName("junk");
+
+    DB.save(bean);
+    assertNotNull(bean.getId());
+
+    bean.setName("junk mod");
+    DB.save(bean);
+
+    ASimpleBean fetched = DB.find(ASimpleBean.class, bean.getId());
+    assertEquals("junk mod", fetched.getName());
+    assertEquals(bean.getName(), fetched.getName());
+
+    DB.delete(bean);
+    ASimpleBean fetched2 = DB.find(ASimpleBean.class, bean.getId());
+    assertNull(fetched2);
+
+    NotEnhancedMappedSuper mappedSuper = new NotEnhancedMappedSuper();
+    assertTrue((mappedSuper instanceof EntityBean));
+  }
+
+}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestReferenceWithConstructorProperties.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestReferenceWithConstructorProperties.java
similarity index 62%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestReferenceWithConstructorProperties.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestReferenceWithConstructorProperties.java
index 6c1626ce5..551db2d8e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/TestReferenceWithConstructorProperties.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/TestReferenceWithConstructorProperties.java
@@ -2,17 +2,14 @@ package io.ebeaninternal.server.deploy;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.Set;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestReferenceWithConstructorProperties extends BaseTestCase {
 
@@ -23,10 +20,10 @@ public class TestReferenceWithConstructorProperties extends BaseTestCase {
   public void test() {
 
     ResetBasicData.reset();
-    Order order = Ebean.getReference(Order.class, 1);
+    Order order = DB.reference(Order.class, 1);
 
-    BeanState beanState = Ebean.getBeanState(order);
-    Set<String> loadedProps = beanState.getLoadedProps();
+    BeanState beanState = DB.beanState(order);
+    Set<String> loadedProps = beanState.loadedProps();
 
     assertEquals(1, loadedProps.size());
     assertTrue(beanState.isReference());
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedCounterLongTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedCounterLongTest.java
similarity index 66%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedCounterLongTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedCounterLongTest.java
index c1d76e037..403fc3d8d 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedCounterLongTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedCounterLongTest.java
@@ -3,28 +3,27 @@ package io.ebeaninternal.server.deploy.generatedproperty;
 import io.ebean.BaseTestCase;
 import io.ebean.bean.EntityBean;
 import io.ebeaninternal.server.deploy.BeanProperty;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 
 public class GeneratedCounterLongTest extends BaseTestCase {
 
   private GeneratedCounterLong counter = new GeneratedCounterLong();
 
-  private BeanProperty version = getBeanDescriptor(Customer.class).getBeanProperty("version");
-
-  @Test(expected = IllegalStateException.class)
-  public void when_null_expect_IllegalStateException() throws Exception {
+  private BeanProperty version = getBeanDescriptor(Customer.class).beanProperty("version");
 
+  @Test
+  public void when_null_expect_IllegalStateException() {
     Customer customer = new Customer();
-    counter.getUpdateValue(version, (EntityBean)customer, System.currentTimeMillis());
+    assertThrows(IllegalStateException.class, () -> counter.getUpdateValue(version, (EntityBean)customer, System.currentTimeMillis()));
   }
 
   @Test
-  public void when_set_expect_incremented() throws Exception {
-
+  public void when_set_expect_incremented() {
     Customer customer = new Customer();
     customer.setVersion(7L);
     Object value = counter.getUpdateValue(version, (EntityBean) customer, System.currentTimeMillis());
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedInsertJavaTimeTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedInsertJavaTimeTest.java
similarity index 78%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedInsertJavaTimeTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedInsertJavaTimeTest.java
index 3d469c783..cd5903485 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedInsertJavaTimeTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/GeneratedInsertJavaTimeTest.java
@@ -1,9 +1,9 @@
 package io.ebeaninternal.server.deploy.generatedproperty;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class GeneratedInsertJavaTimeTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/InsertTimestampFactoryTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/InsertTimestampFactoryTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/InsertTimestampFactoryTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/InsertTimestampFactoryTest.java
index e91507a96..0ce2061f3 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/InsertTimestampFactoryTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/InsertTimestampFactoryTest.java
@@ -2,14 +2,14 @@ package io.ebeaninternal.server.deploy.generatedproperty;
 
 import io.ebean.config.ClassLoadConfig;
 import io.ebeaninternal.server.deploy.meta.DeployBeanProperty;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.OffsetDateTime;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class InsertTimestampFactoryTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/UpdateTimestampFactoryTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/UpdateTimestampFactoryTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/UpdateTimestampFactoryTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/UpdateTimestampFactoryTest.java
index 800423fc8..aa150304e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/UpdateTimestampFactoryTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/generatedproperty/UpdateTimestampFactoryTest.java
@@ -2,14 +2,14 @@ package io.ebeaninternal.server.deploy.generatedproperty;
 
 import io.ebean.config.ClassLoadConfig;
 import io.ebeaninternal.server.deploy.meta.DeployBeanProperty;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.OffsetDateTime;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class UpdateTimestampFactoryTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/parse/AnnotationClassTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/parse/AnnotationClassTest.java
similarity index 87%
rename from ebean-core/src/test/java/io/ebeaninternal/server/deploy/parse/AnnotationClassTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/deploy/parse/AnnotationClassTest.java
index 5b543e764..48d67baee 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/deploy/parse/AnnotationClassTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/deploy/parse/AnnotationClassTest.java
@@ -1,18 +1,16 @@
 package io.ebeaninternal.server.deploy.parse;
 
 import io.ebean.config.DatabaseConfig;
-import io.ebean.config.ServerConfig;
 import io.ebean.config.dbplatform.sqlserver.SqlServer17Platform;
 import io.ebeaninternal.server.core.bootup.BootupClasses;
 import io.ebeaninternal.server.deploy.generatedproperty.GeneratedPropertyFactory;
 import io.ebeaninternal.server.deploy.meta.DeployBeanDescriptor;
 import io.ebeaninternal.server.type.DefaultTypeManager;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
 
 public class AnnotationClassTest {
 
@@ -45,9 +43,8 @@ public class AnnotationClassTest {
     assertThat(columnNames[2]).isEqualTo("col3");
   }
 
-  @SuppressWarnings("unchecked")
-  private AnnotationClass createAnnotationClass(ServerConfig config) {
-
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  private AnnotationClass createAnnotationClass(DatabaseConfig config) {
     DeployUtil deployUtil = new DeployUtil(new DefaultTypeManager(config, new BootupClasses()), config);
 
     DeployBeanInfo deployBeanInfo = new DeployBeanInfo(deployUtil, new DeployBeanDescriptor<>(null, null, null));
@@ -55,10 +52,9 @@ public class AnnotationClassTest {
     return new AnnotationClass(deployBeanInfo, readAnnotationConfig);
   }
 
-  private ServerConfig sqlServerPlatform(boolean allQuotedIdentifiers) {
-
+  private DatabaseConfig sqlServerPlatform(boolean allQuotedIdentifiers) {
     SqlServer17Platform sqlServer17Platform = new SqlServer17Platform();
-    ServerConfig config = new ServerConfig();
+    DatabaseConfig config = new DatabaseConfig();
     config.setDatabasePlatform(sqlServer17Platform);
     config.setAllQuotedIdentifiers(allQuotedIdentifiers);
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/dto/DtoMetaBuilderTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/dto/DtoMetaBuilderTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/dto/DtoMetaBuilderTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/dto/DtoMetaBuilderTest.java
index 2cf97ca85..3d476132c 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/dto/DtoMetaBuilderTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/dto/DtoMetaBuilderTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.dto;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
 import java.util.HashMap;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/executor/DefaultBackgroundExecutorTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/executor/DefaultBackgroundExecutorTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/executor/DefaultBackgroundExecutorTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/executor/DefaultBackgroundExecutorTest.java
index 264edac57..08bc88640 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/executor/DefaultBackgroundExecutorTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/executor/DefaultBackgroundExecutorTest.java
@@ -1,8 +1,7 @@
 package io.ebeaninternal.server.executor;
 
-import io.ebeaninternal.server.executor.DefaultBackgroundExecutor;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.slf4j.MDC;
 
 import java.util.concurrent.Future;
@@ -59,7 +58,7 @@ public class DefaultBackgroundExecutorTest {
   }
 
   @Test
-  @Ignore("test takes long time")
+  @Disabled("test takes long time")
   public void shutdown_when_running_expect_waitAndNiceShutdown() {
 
     DefaultBackgroundExecutor es = new DefaultBackgroundExecutor(1, 20, "test");
@@ -72,7 +71,7 @@ public class DefaultBackgroundExecutorTest {
   }
 
   @Test
-  @Ignore("test takes long time")
+  @Disabled("test takes long time")
   public void shutdown_when_rougeRunnable_expect_InterruptedException() {
 
     DefaultBackgroundExecutor es = new DefaultBackgroundExecutor(1, 10, "test");
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/executor/TestShutdownWithBackgroundTasks.java b/ebean-test/src/test/java/io/ebeaninternal/server/executor/TestShutdownWithBackgroundTasks.java
similarity index 89%
rename from ebean-core/src/test/java/io/ebeaninternal/server/executor/TestShutdownWithBackgroundTasks.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/executor/TestShutdownWithBackgroundTasks.java
index a0a98c38a..9a45dad71 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/executor/TestShutdownWithBackgroundTasks.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/executor/TestShutdownWithBackgroundTasks.java
@@ -4,18 +4,18 @@ import io.ebean.BackgroundExecutor;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Database;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 public class TestShutdownWithBackgroundTasks extends BaseTestCase {
 
   @Test
-  @Ignore
+  @Disabled
   public void test() {
 
     Database server = DB.getDefault();
-    final BackgroundExecutor bg = server.getBackgroundExecutor();
+    final BackgroundExecutor bg = server.backgroundExecutor();
     try {
       for (int i = 0; i < 12; i++) {
         bg.execute(new Job(server, 500, i));
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/AllEqualsExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/AllEqualsExpressionTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/AllEqualsExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/AllEqualsExpressionTest.java
index d26a46b01..43fd9126b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/AllEqualsExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/AllEqualsExpressionTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/BaseExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/BaseExpressionTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/BaseExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/BaseExpressionTest.java
index c11ed25b5..ef44734b8 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/BaseExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/BaseExpressionTest.java
@@ -67,12 +67,12 @@ public abstract class BaseExpressionTest extends BaseTestCase {
     }
 
     @Override
-    public Transaction getTransaction() {
+    public Transaction transaction() {
       return null;
     }
 
     @Override
-    public Query<T> getQuery() {
+    public Query<T> query() {
       return null;
     }
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/BetweenExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/BetweenExpressionTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/BetweenExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/BetweenExpressionTest.java
index 10b529aac..f9ebea4c9 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/BetweenExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/BetweenExpressionTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.expression;
 
 import io.ebeaninternal.api.SpiExpression;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/BetweenPropertyExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/BetweenPropertyExpressionTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/BetweenPropertyExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/BetweenPropertyExpressionTest.java
index 4685f1290..be487ca00 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/BetweenPropertyExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/BetweenPropertyExpressionTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpressionTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpressionTest.java
index 75f033ced..4691cc199 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpressionTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.expression;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/DefaultExampleExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/DefaultExampleExpressionTest.java
similarity index 99%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/DefaultExampleExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/DefaultExampleExpressionTest.java
index a593bfe01..452db7dbf 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/DefaultExampleExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/DefaultExampleExpressionTest.java
@@ -8,7 +8,7 @@ import io.ebeaninternal.api.ManyWhereJoins;
 import io.ebeaninternal.api.SpiQuery;
 import io.ebeaninternal.server.core.OrmQueryRequest;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionFactoryTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionFactoryTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionFactoryTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionFactoryTest.java
index 227f11b3f..47be406be 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionFactoryTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionFactoryTest.java
@@ -2,7 +2,7 @@ package io.ebeaninternal.server.expression;
 
 import io.ebean.Expression;
 import io.ebeaninternal.api.SpiExpression;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionListTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionListTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionListTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionListTest.java
index 89e2dcd39..1fa245832 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionListTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/DefaultExpressionListTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.expression;
 
 import io.ebean.ExpressionList;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/ExistsQueryExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/ExistsQueryExpressionTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/ExistsQueryExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/ExistsQueryExpressionTest.java
index ee2f37c44..b869096a1 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/ExistsQueryExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/ExistsQueryExpressionTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/IdExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/IdExpressionTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/IdExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/IdExpressionTest.java
index 247ac62c2..084410752 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/IdExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/IdExpressionTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.expression;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/IdInExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/IdInExpressionTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/IdInExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/IdInExpressionTest.java
index 45fa3858a..ded5e7772 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/IdInExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/IdInExpressionTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/InExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/InExpressionTest.java
similarity index 99%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/InExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/InExpressionTest.java
index 11ff0eae6..17039e605 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/InExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/InExpressionTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/InPairsExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/InPairsExpressionTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/InPairsExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/InPairsExpressionTest.java
index eee6f1556..b5f1254e5 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/InPairsExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/InPairsExpressionTest.java
@@ -1,10 +1,10 @@
 package io.ebeaninternal.server.expression;
 
 import io.ebean.Pairs;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static junit.framework.TestCase.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class InPairsExpressionTest extends BaseExpressionTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/InQueryExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/InQueryExpressionTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/InQueryExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/InQueryExpressionTest.java
index 1b6345846..1ab4853b5 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/InQueryExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/InQueryExpressionTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/InRangeExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/InRangeExpressionTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/InRangeExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/InRangeExpressionTest.java
index b3d607728..921581333 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/InRangeExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/InRangeExpressionTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.expression;
 
 import io.ebeaninternal.api.SpiExpression;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/IsEmptyExpressionQueryTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/IsEmptyExpressionQueryTest.java
similarity index 86%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/IsEmptyExpressionQueryTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/IsEmptyExpressionQueryTest.java
index dba74742e..cf2a11e04 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/IsEmptyExpressionQueryTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/IsEmptyExpressionQueryTest.java
@@ -1,10 +1,10 @@
 package io.ebeaninternal.server.expression;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
@@ -21,7 +21,7 @@ public class IsEmptyExpressionQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id")
       .where().isEmpty("contacts")
       .query();
@@ -35,13 +35,13 @@ public class IsEmptyExpressionQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(EUserNoFk.class)
+    DB.find(EUserNoFk.class)
       .where().isEmpty("files")
       .delete();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
 
     if (isPlatformSupportsDeleteTableAlias()) {
@@ -58,7 +58,7 @@ public class IsEmptyExpressionQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id")
       .where().isNotEmpty("contacts")
       .query();
@@ -72,7 +72,7 @@ public class IsEmptyExpressionQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .select("id")
       .where().isEmpty("notes")
       .query();
@@ -86,7 +86,7 @@ public class IsEmptyExpressionQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .select("id")
       .where().isNotEmpty("notes")
       .query();
@@ -101,7 +101,7 @@ public class IsEmptyExpressionQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .select("id")
       .where().isEmpty("notes")
       .query();
@@ -115,7 +115,7 @@ public class IsEmptyExpressionQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id")
       .where().isEmpty("contacts.notes")
       .query();
@@ -134,7 +134,7 @@ public class IsEmptyExpressionQueryTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id")
       .where().isNotEmpty("contacts.notes")
       .query();
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/JsonPathExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/JsonPathExpressionTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/JsonPathExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/JsonPathExpressionTest.java
index 1a4f82dd5..83438d870 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/JsonPathExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/JsonPathExpressionTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/JunctionExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/JunctionExpressionTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/JunctionExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/JunctionExpressionTest.java
index fe2e1224e..b28d44c05 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/JunctionExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/JunctionExpressionTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.server.expression;
 import io.ebean.Expr;
 import io.ebean.Expression;
 import io.ebean.Junction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class JunctionExpressionTest extends BaseExpressionTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/LikeExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/LikeExpressionTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/LikeExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/LikeExpressionTest.java
index 51f0eeaae..3012daf4d 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/LikeExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/LikeExpressionTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.expression;
 
 import io.ebean.LikeType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/LogicExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/LogicExpressionTest.java
similarity index 99%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/LogicExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/LogicExpressionTest.java
index 601c607c6..2ddbd367e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/LogicExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/LogicExpressionTest.java
@@ -2,7 +2,7 @@ package io.ebeaninternal.server.expression;
 
 import io.ebean.Expr;
 import io.ebean.Expression;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/NoopExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/NoopExpressionTest.java
similarity index 83%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/NoopExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/NoopExpressionTest.java
index bb745b47c..69bbbf6db 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/NoopExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/NoopExpressionTest.java
@@ -1,9 +1,9 @@
 package io.ebeaninternal.server.expression;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.onetoone.album.Cover;
 
@@ -17,7 +17,7 @@ public class NoopExpressionTest extends BaseExpressionTest {
   @Test
   public void test() {
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id")
       .where().add(NoopExpression.INSTANCE)
       .query();
@@ -31,22 +31,22 @@ public class NoopExpressionTest extends BaseExpressionTest {
   @Test
   public void test_withSoftDeleteBean() {
 
-    Query<Cover> query = Ebean.find(Cover.class)
+    Query<Cover> query = DB.find(Cover.class)
       .where().add(NoopExpression.INSTANCE)
       .query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     query.findCount();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select count(*) from cover t0 where 1=1 and");
   }
 
   @Test
   public void test_withPreAndPost() {
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id")
       .where().eq("name", null)
       .add(NoopExpression.INSTANCE)
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/NotExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/NotExpressionTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/NotExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/NotExpressionTest.java
index a65b81c97..fc82a7dc9 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/NotExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/NotExpressionTest.java
@@ -2,7 +2,7 @@ package io.ebeaninternal.server.expression;
 
 
 import io.ebean.Expression;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static io.ebean.Expr.eq;
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/NullExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/NullExpressionTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/NullExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/NullExpressionTest.java
index 02c47948f..302ea3f9e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/NullExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/NullExpressionTest.java
@@ -2,7 +2,7 @@ package io.ebeaninternal.server.expression;
 
 import io.ebeaninternal.api.ManyWhereJoins;
 import io.ebeaninternal.api.SpiExpression;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/PrepareDocNestedTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/PrepareDocNestedTest.java
similarity index 89%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/PrepareDocNestedTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/PrepareDocNestedTest.java
index b33019cce..58e33b9d2 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/PrepareDocNestedTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/PrepareDocNestedTest.java
@@ -1,22 +1,22 @@
 package io.ebeaninternal.server.expression;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.ExpressionList;
 import io.ebeaninternal.api.SpiExpression;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
-import org.junit.Test;
 
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class PrepareDocNestedTest extends BaseTestCase {
   @Test
   public void prepare() throws Exception {
 
-    ExpressionList<Order> where = Ebean.find(Order.class)
+    ExpressionList<Order> where = DB.find(Order.class)
       .where()
       .gt("details.orderQty", 1)
       .query().where();
@@ -33,7 +33,7 @@ public class PrepareDocNestedTest extends BaseTestCase {
   @Test
   public void prepare_when_multipleOfSamePath() throws Exception {
 
-    ExpressionList<Order> where = Ebean.find(Order.class)
+    ExpressionList<Order> where = DB.find(Order.class)
       .where()
       .gt("details.orderQty", 1)
       .gt("details.unitPrice", 1)
@@ -51,7 +51,7 @@ public class PrepareDocNestedTest extends BaseTestCase {
   @Test
   public void prepare_when_mixed() throws Exception {
 
-    ExpressionList<Order> where = Ebean.find(Order.class)
+    ExpressionList<Order> where = DB.find(Order.class)
       .where()
       .gt("customer.id", 1)
       .gt("details.orderQty", 1)
@@ -73,7 +73,7 @@ public class PrepareDocNestedTest extends BaseTestCase {
   @Test
   public void prepare_when_nestedJunction() throws Exception {
 
-    ExpressionList<Order> where = Ebean.find(Order.class)
+    ExpressionList<Order> where = DB.find(Order.class)
       .where()
       .not()
       .gt("customer.id", 1)
@@ -97,7 +97,7 @@ public class PrepareDocNestedTest extends BaseTestCase {
   @Test
   public void prepare_when_nestedMultiple() throws Exception {
 
-    ExpressionList<Order> where = Ebean.find(Order.class)
+    ExpressionList<Order> where = DB.find(Order.class)
       .where()
       .isNotNull("shipments.shipTime")
       .gt("details.orderQty", 1)
@@ -122,7 +122,7 @@ public class PrepareDocNestedTest extends BaseTestCase {
   @Test
   public void prepare_when_manyMixed() throws Exception {
 
-    ExpressionList<Order> where = Ebean.find(Order.class)
+    ExpressionList<Order> where = DB.find(Order.class)
       .where()
       .gt("customer.id", 1)             // 0
       .isNotNull("shipments.shipTime")  // shipments 0
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/RawExpressionBuilderTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/RawExpressionBuilderTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/RawExpressionBuilderTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/RawExpressionBuilderTest.java
index 8f3c4bf43..81e5c312b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/RawExpressionBuilderTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/RawExpressionBuilderTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/RawExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/RawExpressionTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/RawExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/RawExpressionTest.java
index eb12ff460..c87e46c47 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/RawExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/RawExpressionTest.java
@@ -1,9 +1,9 @@
 package io.ebeaninternal.server.expression;
 
-import org.junit.Test;
+import io.ebeaninternal.api.BindValuesKey;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import io.ebeaninternal.api.BindValuesKey;
 
 public class RawExpressionTest extends BaseExpressionTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/SameTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/SameTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/SameTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/SameTest.java
index f5cd05852..76e3d27a3 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/SameTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/SameTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/SimpleExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/SimpleExpressionTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/SimpleExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/SimpleExpressionTest.java
index 1ce846e45..d9ce5d9fd 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/SimpleExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/SimpleExpressionTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.expression;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/TDSpiExpressionRequest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/TDSpiExpressionRequest.java
similarity index 100%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/TDSpiExpressionRequest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/TDSpiExpressionRequest.java
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/H2DbExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/H2DbExpressionTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/H2DbExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/H2DbExpressionTest.java
index 9cd0f687c..e002e84ed 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/H2DbExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/H2DbExpressionTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.expression.platform;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/HanaDbExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/HanaDbExpressionTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/HanaDbExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/HanaDbExpressionTest.java
index c367ba601..0daf5ea9f 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/HanaDbExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/HanaDbExpressionTest.java
@@ -3,9 +3,9 @@ package io.ebeaninternal.server.expression.platform;
 import io.ebeaninternal.api.SpiExpressionRequest;
 import io.ebeaninternal.server.expression.DefaultExpressionRequest;
 import io.ebeaninternal.server.expression.Op;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class HanaDbExpressionTest {
   private HanaDbExpression expression = new HanaDbExpression();
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/MySqlDbExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/MySqlDbExpressionTest.java
similarity index 85%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/MySqlDbExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/MySqlDbExpressionTest.java
index d53657bec..032075298 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/MySqlDbExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/MySqlDbExpressionTest.java
@@ -3,9 +3,9 @@ package io.ebeaninternal.server.expression.platform;
 import io.ebeaninternal.api.SpiExpressionRequest;
 import io.ebeaninternal.server.expression.DefaultExpressionRequest;
 import io.ebeaninternal.server.expression.Op;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class MySqlDbExpressionTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/OracleDbExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/OracleDbExpressionTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/OracleDbExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/OracleDbExpressionTest.java
index 6608927c2..d05f61594 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/OracleDbExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/OracleDbExpressionTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression.platform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/PostgresCastTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/PostgresCastTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/PostgresCastTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/PostgresCastTest.java
index 526ca3353..80c0ccff0 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/PostgresCastTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/PostgresCastTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression.platform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/PostgresDbExpressionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/PostgresDbExpressionTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/PostgresDbExpressionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/PostgresDbExpressionTest.java
index e9e4ae2d4..1a4c4c85b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/expression/platform/PostgresDbExpressionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/expression/platform/PostgresDbExpressionTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.expression.platform;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/grammer/EqlParserTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/grammer/EqlParserTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/grammer/EqlParserTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/grammer/EqlParserTest.java
index e6281364b..38fceeefc 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/grammer/EqlParserTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/grammer/EqlParserTest.java
@@ -2,14 +2,13 @@ package io.ebeaninternal.server.grammer;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.Query;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
+import io.ebean.test.LoggedSql;
 import io.ebeaninternal.api.SpiQuery;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.ResetBasicData;
@@ -21,13 +20,14 @@ import java.util.HashSet;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class EqlParserTest extends BaseTestCase {
 
 
-  @Test(expected = IllegalArgumentException.class)
+  @Test
   public void illegal_syntax() {
-    parse("find Article where name = :p0");
+    assertThrows(IllegalArgumentException.class, () -> parse("find Article where name = :p0"));
   }
 
   @Test
@@ -389,27 +389,23 @@ public class EqlParserTest extends BaseTestCase {
     assertSql(query).doesNotContain("where");
   }
 
-  @Test(expected = IllegalArgumentException.class)
+  @Test//(expected = IllegalArgumentException.class)
   public void query_inOrEmpty_withVals() {
-
-    Query<Customer> query = parse("where name inOrEmpty (:names)");
-    query.setParameter("names", Arrays.asList("Baz", "Maz", "Jim"));
-    query.findList();
-
-    platformAssertIn(query.getGeneratedSql(), "where t0.name");
+    assertThrows(IllegalArgumentException.class, () -> parse("where name inOrEmpty (:names)"));
+//    query.setParameter("names", Arrays.asList("Baz", "Maz", "Jim"));
+//    query.findList();
+//    platformAssertIn(query.getGeneratedSql(), "where t0.name");
   }
 
   /**
    * This test fails in that we can't use inOrEmpty with named parameters.
    */
-  @Test(expected = IllegalArgumentException.class)
+  @Test//(expected = IllegalArgumentException.class)
   public void query_inOrEmpty_withNamedParams_expect_IllegalArgument() {
-
-    Query<Customer> query = parse("where name inOrEmpty (:names)");
-    query.setParameter("names", new ArrayList<>());
-    query.findList();
-
-    assertSql(query).doesNotContain("where");
+    assertThrows(IllegalArgumentException.class, () -> parse("where name inOrEmpty (:names)"));
+//    query.setParameter("names", new ArrayList<>());
+//    assertThrows(IllegalArgumentException.class, query::findList);
+//    assertSql(query).doesNotContain("where");
   }
 
   @Test
@@ -535,12 +531,12 @@ public class EqlParserTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Query<Customer> query = parse("select name fetch billingAddress (line1, city) fetch contacts (email) limit 10");
     query.findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t1.id, t1.line_1, t1.city from o_customer t0 left join o_address");
     assertSql(sql.get(1)).contains("select t0.customer_id, t0.id, t0.email from contact t0 where (t0.customer_id)");
@@ -698,7 +694,7 @@ public class EqlParserTest extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<OrderDetail> query = Ebean.createQuery(OrderDetail.class, "select sum(orderQty) fetch `order` (id)");
+    Query<OrderDetail> query = DB.createQuery(OrderDetail.class, "select sum(orderQty) fetch `order` (id)");
     List<OrderDetail> details = query.findList();
 
     assertThat(details).isNotEmpty();
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/grammer/ParseFetchConfigTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/grammer/ParseFetchConfigTest.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebeaninternal/server/grammer/ParseFetchConfigTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/grammer/ParseFetchConfigTest.java
index c4976f56d..6d86c65d1 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/grammer/ParseFetchConfigTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/grammer/ParseFetchConfigTest.java
@@ -1,10 +1,10 @@
 package io.ebeaninternal.server.grammer;
 
 import io.ebean.FetchConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class ParseFetchConfigTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/idgen/TestUuidGenerator.java b/ebean-test/src/test/java/io/ebeaninternal/server/idgen/TestUuidGenerator.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/idgen/TestUuidGenerator.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/idgen/TestUuidGenerator.java
index 3623fdd73..50f8e81b9 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/idgen/TestUuidGenerator.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/idgen/TestUuidGenerator.java
@@ -5,7 +5,7 @@
 package io.ebeaninternal.server.idgen;
 
 import io.ebean.config.dbplatform.PlatformIdGenerator;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Map;
 import java.util.UUID;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/lib/ShutdownManagerTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/lib/ShutdownManagerTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/server/lib/ShutdownManagerTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/lib/ShutdownManagerTest.java
index c48756ed7..f07ffe3a6 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/lib/ShutdownManagerTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/lib/ShutdownManagerTest.java
@@ -2,18 +2,17 @@ package io.ebeaninternal.server.lib;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Database;
 import io.ebean.DatabaseFactory;
 import io.ebean.event.ShutdownManager;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 public class ShutdownManagerTest extends BaseTestCase {
 
   /**
    * Run this test manually. Most typical when we want the application code to control shutdown.
    */
-  @Ignore
+  @Disabled
   @Test
   public void test_disableShutdownHook_shutdownManually() {
     // disable hook to make sure app code controls when shutdown is executed
@@ -28,7 +27,7 @@ public class ShutdownManagerTest extends BaseTestCase {
   /**
    * Run this test manually.
    */
-  @Ignore
+  @Disabled
   @Test
   public void test_shutdownHook() {
     DB.getDefault(); // shutdown fired via shutdown hook, default behaviour
@@ -37,7 +36,7 @@ public class ShutdownManagerTest extends BaseTestCase {
   /**
    * Run this test manually.
    */
-  @Ignore
+  @Disabled
   @Test
   public void test_disableShutdownHook() {
     DB.getDefault();
@@ -47,7 +46,7 @@ public class ShutdownManagerTest extends BaseTestCase {
   /**
    * Run this test manually.
    */
-  @Ignore
+  @Disabled
   @Test
   public void test_shutdownManually() {
     DB.getDefault();
@@ -59,7 +58,7 @@ public class ShutdownManagerTest extends BaseTestCase {
   /**
    * Run this test manually.
    */
-  @Ignore
+  @Disabled
   @Test
   public void test_deregisterShutdownHook() {
     DB.getDefault();
@@ -69,7 +68,7 @@ public class ShutdownManagerTest extends BaseTestCase {
   /**
    * Run this test manually.
    */
-  @Ignore
+  @Disabled
   @Test
   public void test_noShutdownHook() {
     System.setProperty("ebean.registerShutdownHook", "false");
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/loadcontext/DLoadContextTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/loadcontext/DLoadContextTest.java
similarity index 84%
rename from ebean-core/src/test/java/io/ebeaninternal/server/loadcontext/DLoadContextTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/loadcontext/DLoadContextTest.java
index 4bffce7d8..a4499ae96 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/loadcontext/DLoadContextTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/loadcontext/DLoadContextTest.java
@@ -6,8 +6,8 @@ import io.ebean.Query;
 import io.ebeaninternal.server.core.OrmQueryRequest;
 import io.ebeaninternal.server.core.OrmQueryRequestTestHelper;
 import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -28,7 +28,7 @@ public class DLoadContextTest extends BaseTestCase {
     queryRequest.initTransIfRequired();
     queryRequest.endTransIfRequired();
 
-    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
     DLoadBeanContext customer = graphContext.getBeanContext("customer");
 
     assertThat(customer.batchSize).isEqualTo(10);
@@ -41,7 +41,7 @@ public class DLoadContextTest extends BaseTestCase {
     queryRequest.initTransIfRequired();
     queryRequest.endTransIfRequired();
 
-    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
     DLoadBeanContext customer = graphContext.getBeanContext("customer");
 
     assertThat(customer.batchSize).isEqualTo(100);
@@ -54,7 +54,7 @@ public class DLoadContextTest extends BaseTestCase {
     queryRequest.initTransIfRequired();
     queryRequest.endTransIfRequired();
 
-    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
     DLoadBeanContext customer = graphContext.getBeanContext("customer");
 
     assertThat(customer.batchSize).isEqualTo(100);
@@ -67,7 +67,7 @@ public class DLoadContextTest extends BaseTestCase {
     queryRequest.initTransIfRequired();
     queryRequest.endTransIfRequired();
 
-    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
     DLoadBeanContext customer = graphContext.getBeanContext("customer");
 
     assertThat(customer.batchSize).isEqualTo(50);
@@ -80,7 +80,7 @@ public class DLoadContextTest extends BaseTestCase {
     queryRequest.initTransIfRequired();
     queryRequest.endTransIfRequired();
 
-    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
     DLoadBeanContext customer = graphContext.getBeanContext("customer");
 
     assertThat(customer.batchSize).isEqualTo(100);
@@ -89,13 +89,13 @@ public class DLoadContextTest extends BaseTestCase {
   @Test
   public void construct_when_fetch_expect_100_100_batchSize() {
 
-    BeanPropertyAssocMany<?> many = (BeanPropertyAssocMany<?>)getBeanDescriptor(Order.class).getBeanProperty("details");
+    BeanPropertyAssocMany<?> many = (BeanPropertyAssocMany<?>)getBeanDescriptor(Order.class).beanProperty("details");
     // the fetch is converted to a query join due to the maxRows
     OrmQueryRequest<Order> queryRequest = queryRequest(query().fetch("details").setMaxRows(50));
     queryRequest.initTransIfRequired();
     queryRequest.endTransIfRequired();
 
-    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
     DLoadManyContext details = graphContext.getManyContext("details", many);
 
     assertThat(details.batchSize).isEqualTo(100);
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/persist/BatchDepthOrderTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/persist/BatchDepthOrderTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/server/persist/BatchDepthOrderTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/persist/BatchDepthOrderTest.java
index d9640e7da..ec71fcf03 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/persist/BatchDepthOrderTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/persist/BatchDepthOrderTest.java
@@ -1,8 +1,8 @@
 package io.ebeaninternal.server.persist;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class BatchDepthOrderTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/persist/FlagsTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/persist/FlagsTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/persist/FlagsTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/persist/FlagsTest.java
index 0753a3841..5c1f8c879 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/persist/FlagsTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/persist/FlagsTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.persist;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/persist/TrimLogSqlTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/persist/TrimLogSqlTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/persist/TrimLogSqlTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/persist/TrimLogSqlTest.java
index a90fc99c7..b9bf22ae9 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/persist/TrimLogSqlTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/persist/TrimLogSqlTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.persist;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/profile/BasicProfileLocationTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/profile/BasicProfileLocationTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/profile/BasicProfileLocationTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/profile/BasicProfileLocationTest.java
index 9d99b17ce..3762cd51b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/profile/BasicProfileLocationTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/profile/BasicProfileLocationTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.profile;
 
 import io.ebean.metric.MetricFactory;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/profile/DTimedMetricMapTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/profile/DTimedMetricMapTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/profile/DTimedMetricMapTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/profile/DTimedMetricMapTest.java
index cb6d4d662..2fc54e117 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/profile/DTimedMetricMapTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/profile/DTimedMetricMapTest.java
@@ -2,7 +2,7 @@ package io.ebeaninternal.server.profile;
 
 import io.ebean.meta.BasicMetricVisitor;
 import io.ebean.meta.MetaTimedMetric;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/profile/DTimedMetricTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/profile/DTimedMetricTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/profile/DTimedMetricTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/profile/DTimedMetricTest.java
index 6dbbb45d3..46285255e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/profile/DTimedMetricTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/profile/DTimedMetricTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.profile;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/profile/SortMetricTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/profile/SortMetricTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebeaninternal/server/profile/SortMetricTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/profile/SortMetricTest.java
index 29658566c..570913db7 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/profile/SortMetricTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/profile/SortMetricTest.java
@@ -2,14 +2,14 @@ package io.ebeaninternal.server.profile;
 
 import io.ebean.meta.MetaTimedMetric;
 import io.ebean.meta.SortMetric;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.stream.Collectors;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class SortMetricTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/profile/UtilLocationTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/profile/UtilLocationTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebeaninternal/server/profile/UtilLocationTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/profile/UtilLocationTest.java
index 0b26078ff..12f1edcd9 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/profile/UtilLocationTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/profile/UtilLocationTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.profile;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/query/DbOrderByTrimTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/query/DbOrderByTrimTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/query/DbOrderByTrimTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/query/DbOrderByTrimTest.java
index d515f6a71..1f918c97d 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/query/DbOrderByTrimTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/query/DbOrderByTrimTest.java
@@ -1,8 +1,8 @@
 package io.ebeaninternal.server.query;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DbOrderByTrimTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/query/DefaultSqlRowTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/query/DefaultSqlRowTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/query/DefaultSqlRowTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/query/DefaultSqlRowTest.java
index 3ceb37305..3d33ca922 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/query/DefaultSqlRowTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/query/DefaultSqlRowTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.query;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/query/LimitOffsetPagedListTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/query/LimitOffsetPagedListTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/query/LimitOffsetPagedListTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/query/LimitOffsetPagedListTest.java
index d7de421c7..3286c7e4b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/query/LimitOffsetPagedListTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/query/LimitOffsetPagedListTest.java
@@ -3,10 +3,10 @@ package io.ebeaninternal.server.query;
 import io.ebean.BaseTestCase;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.SpiQuery;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class LimitOffsetPagedListTest extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/query/OrderVersionDescTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/query/OrderVersionDescTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebeaninternal/server/query/OrderVersionDescTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/query/OrderVersionDescTest.java
index 35f3cf546..e278eb6d7 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/query/OrderVersionDescTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/query/OrderVersionDescTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.query;
 
 import io.ebean.Version;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 import java.util.ArrayList;
@@ -9,7 +9,7 @@ import java.util.Collections;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class OrderVersionDescTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/query/RawSqlQueryPlanKeyTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/query/RawSqlQueryPlanKeyTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/query/RawSqlQueryPlanKeyTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/query/RawSqlQueryPlanKeyTest.java
index 906492fe5..dd32c9317 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/query/RawSqlQueryPlanKeyTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/query/RawSqlQueryPlanKeyTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.query;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/query/SplitNameTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/query/SplitNameTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/server/query/SplitNameTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/query/SplitNameTest.java
index d26322792..7351ab2f4 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/query/SplitNameTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/query/SplitNameTest.java
@@ -1,10 +1,10 @@
 package io.ebeaninternal.server.query;
 
 import io.ebean.util.SplitName;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class SplitNameTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/query/SqlTreeAliasTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/query/SqlTreeAliasTest.java
similarity index 87%
rename from ebean-core/src/test/java/io/ebeaninternal/server/query/SqlTreeAliasTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/query/SqlTreeAliasTest.java
index d2dda1092..c12786757 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/query/SqlTreeAliasTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/query/SqlTreeAliasTest.java
@@ -1,9 +1,9 @@
 package io.ebeaninternal.server.query;
 
 import io.ebeaninternal.api.SpiQuery;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class SqlTreeAliasTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/query/SqlTreeBuilderTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/query/SqlTreeBuilderTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/query/SqlTreeBuilderTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/query/SqlTreeBuilderTest.java
index 241c218da..6a03ea57f 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/query/SqlTreeBuilderTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/query/SqlTreeBuilderTest.java
@@ -1,8 +1,8 @@
 package io.ebeaninternal.server.query;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class SqlTreeBuilderTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/query/TestFutureRowCountErrorHandling.java b/ebean-test/src/test/java/io/ebeaninternal/server/query/TestFutureRowCountErrorHandling.java
similarity index 68%
rename from ebean-core/src/test/java/io/ebeaninternal/server/query/TestFutureRowCountErrorHandling.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/query/TestFutureRowCountErrorHandling.java
index 1e9bf307d..194d92aa0 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/query/TestFutureRowCountErrorHandling.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/query/TestFutureRowCountErrorHandling.java
@@ -1,20 +1,15 @@
 package io.ebeaninternal.server.query;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import io.ebean.FutureIds;
-import io.ebean.FutureList;
-import io.ebean.FutureRowCount;
-import io.ebean.Query;
-import io.ebean.Transaction;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.concurrent.ExecutionException;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
 public class TestFutureRowCountErrorHandling extends BaseTestCase {
 
   @Test
@@ -22,7 +17,7 @@ public class TestFutureRowCountErrorHandling extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     Query<Customer> query = server.createQuery(Customer.class)
       .where().eq("doesNotExist", "this will fail")
@@ -35,11 +30,11 @@ public class TestFutureRowCountErrorHandling extends BaseTestCase {
 
     try {
       futureRowCount.get();
-      Assert.assertTrue("never get here as the SQL is invalid", false);
+      fail("never get here as the SQL is invalid");
 
     } catch (ExecutionException e) {
       // Confirm the Transaction has been rolled back
-      Assert.assertFalse("Underlying transaction was rolled back cleanly", t.isActive());
+      assertFalse(t.isActive());
     }
 
   }
@@ -49,7 +44,7 @@ public class TestFutureRowCountErrorHandling extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     Query<Customer> query = server.createQuery(Customer.class)
       .where().eq("doesNotExist", "this will fail")
@@ -62,11 +57,11 @@ public class TestFutureRowCountErrorHandling extends BaseTestCase {
 
     try {
       internalFuture.get();
-      Assert.assertTrue("never get here as the SQL is invalid", false);
+      fail("never get here as the SQL is invalid");
 
     } catch (ExecutionException e) {
       // Confirm the Transaction has been rolled back
-      Assert.assertFalse("Underlying transaction was rolled back cleanly", t.isActive());
+      assertFalse(t.isActive());
     }
 
   }
@@ -77,7 +72,7 @@ public class TestFutureRowCountErrorHandling extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     Query<Customer> query = server.createQuery(Customer.class)
       .where().eq("doesNotExist", "this will fail")
@@ -90,11 +85,11 @@ public class TestFutureRowCountErrorHandling extends BaseTestCase {
 
     try {
       internalFuture.get();
-      Assert.assertTrue("never get here as the SQL is invalid", false);
+      fail("never get here as the SQL is invalid");
 
     } catch (ExecutionException e) {
       // Confirm the Transaction has been rolled back
-      Assert.assertFalse("Underlying transaction was rolled back cleanly", t.isActive());
+      assertFalse(t.isActive());
     }
 
   }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/BindValuesKeyTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/BindValuesKeyTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/querydefn/BindValuesKeyTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/querydefn/BindValuesKeyTest.java
index 1a7d3b39f..c2712478a 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/BindValuesKeyTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/BindValuesKeyTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.querydefn;
 
 import io.ebeaninternal.api.BindValuesKey;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/DefaultOrmQueryTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/DefaultOrmQueryTest.java
similarity index 67%
rename from ebean-core/src/test/java/io/ebeaninternal/server/querydefn/DefaultOrmQueryTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/querydefn/DefaultOrmQueryTest.java
index b2b4902ad..305e7694b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/DefaultOrmQueryTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/DefaultOrmQueryTest.java
@@ -3,11 +3,11 @@ package io.ebeaninternal.server.querydefn;
 
 import io.ebean.BaseTestCase;
 import io.ebean.CacheMode;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebeaninternal.api.BindValuesKey;
 import io.ebeaninternal.api.SpiQuery;
 import io.ebeaninternal.server.core.OrmQueryRequest;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 
@@ -18,7 +18,7 @@ public class DefaultOrmQueryTest extends BaseTestCase {
   @Test
   public void when_forUpdate_then_excludeFromBeanCache() {
 
-    DefaultOrmQuery<Customer> q1 = (DefaultOrmQuery<Customer>) Ebean.find(Customer.class)
+    DefaultOrmQuery<Customer> q1 = (DefaultOrmQuery<Customer>) DB.find(Customer.class)
       .forUpdate().where().eq("id", 42).query();
 
     assertThat(q1.getUseBeanCache()).isSameAs(CacheMode.OFF);
@@ -27,7 +27,7 @@ public class DefaultOrmQueryTest extends BaseTestCase {
   @Test
   public void checkForId_when_eqId_then_translatedTo_setId() {
 
-    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().eq("id", 42).query();
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().eq("id", 42).query();
     assertThat(q1.getWhereExpressions()).isNotNull();
     assertThat(q1.getId()).isNull();
 
@@ -40,7 +40,7 @@ public class DefaultOrmQueryTest extends BaseTestCase {
   @Test
   public void checkForId_when_idEq_ok() {
 
-    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().idEq(42).query();
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().idEq(42).query();
     assertThat(q1.getId()).isEqualTo(42);
     assertThat(q1.isFindById()).isTrue();
     assertThat(q1.getId()).isEqualTo(42);
@@ -49,7 +49,7 @@ public class DefaultOrmQueryTest extends BaseTestCase {
   @Test
   public void checkForId_when_setId_ok() {
 
-    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).setId(42);
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).setId(42);
     assertThat(q1.getId()).isEqualTo(42);
     assertThat(q1.isFindById()).isTrue();
     assertThat(q1.getId()).isEqualTo(42);
@@ -58,8 +58,8 @@ public class DefaultOrmQueryTest extends BaseTestCase {
   @Test
   public void when_addWhere_then_planChanges() {
 
-    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("name", "a", "b", "c").query();
-    DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("id", 2, 2, 3).query();
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("name", "a", "b", "c").query();
+    DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("id", 2, 2, 3).query();
 
     prepare(q1, q2);
     assertThat(q1.createQueryPlanKey()).isNotEqualTo(q2.createQueryPlanKey());
@@ -69,8 +69,8 @@ public class DefaultOrmQueryTest extends BaseTestCase {
   @Test
   public void when_sameWhereWithDiffBindValues_then_planSame_bindDiff() {
 
-    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("id", 1, 2, 3).query();
-    DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("id", 2, 2, 3).query();
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("id", 1, 2, 3).query();
+    DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("id", 2, 2, 3).query();
 
     prepare(q1, q2);
     assertThat(q1.createQueryPlanKey()).isEqualTo(q2.createQueryPlanKey());
@@ -80,8 +80,8 @@ public class DefaultOrmQueryTest extends BaseTestCase {
   @Test
   public void when_sameWhereAndBindValues_then_planSameAndBind() {
 
-    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("id", 1, 2, 3).query();
-    DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("id", 1, 2, 3).query();
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("id", 1, 2, 3).query();
+    DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("id", 1, 2, 3).query();
 
     prepare(q1, q2);
     assertThat(q1.createQueryPlanKey()).isEqualTo(q2.createQueryPlanKey());
@@ -91,11 +91,11 @@ public class DefaultOrmQueryTest extends BaseTestCase {
   @Test
   public void when_diffFirstMaxRows_then_differentPlan() {
 
-    DefaultOrmQuery<Order> query1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class)
+    DefaultOrmQuery<Order> query1 = (DefaultOrmQuery<Order>) DB.find(Order.class)
       .setFirstRow(0)
       .setMaxRows(31);
 
-    DefaultOrmQuery<Order> query2 = (DefaultOrmQuery<Order>) Ebean.find(Order.class)
+    DefaultOrmQuery<Order> query2 = (DefaultOrmQuery<Order>) DB.find(Order.class)
       .setFirstRow(1)
       .setMaxRows(0);
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailParserTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailParserTest.java
similarity index 84%
rename from ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailParserTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailParserTest.java
index f7f829118..d6354f9a0 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailParserTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailParserTest.java
@@ -1,11 +1,10 @@
 package io.ebeaninternal.server.querydefn;
 
 import io.ebean.BaseTestCase;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 
 public class OrmQueryDetailParserTest extends BaseTestCase {
@@ -14,19 +13,18 @@ public class OrmQueryDetailParserTest extends BaseTestCase {
     return new OrmQueryDetailParser(query).parse();
   }
 
-  @Test(expected = NullPointerException.class)
-  public void parse_when_nullString() throws Exception {
-    parse(null);
+  @Test
+  public void parse_when_nullString() {
+    assertThrows(NullPointerException.class, () -> parse(null));
   }
 
   @Test
-  public void parse_when_emptyString() throws Exception {
+  public void parse_when_emptyString() {
     assertTrue(parse("").isEmpty());
   }
 
   @Test
-  public void testParseBasic() throws Exception {
-
+  public void testParseBasic() {
     OrmQueryDetail detail = parse("select (id,name)");
 
     OrmQueryProperties root = detail.getChunk(null, false);
@@ -35,8 +33,7 @@ public class OrmQueryDetailParserTest extends BaseTestCase {
   }
 
   @Test
-  public void testParseEmptySelect() throws Exception {
-
+  public void testParseEmptySelect() {
     OrmQueryDetail detail = parse("select  fetch customer (email)");
 
     OrmQueryProperties root = detail.getChunk(null, false);
@@ -49,8 +46,7 @@ public class OrmQueryDetailParserTest extends BaseTestCase {
   }
 
   @Test
-  public void testParseSelectFetch() throws Exception {
-
+  public void testParseSelectFetch() {
     OrmQueryDetail detail = parse("select (id,name) fetch customer (email)");
 
     OrmQueryProperties root = detail.getChunk(null, false);
@@ -63,8 +59,7 @@ public class OrmQueryDetailParserTest extends BaseTestCase {
   }
 
   @Test
-  public void testParseSelectFetchMore() throws Exception {
-
+  public void testParseSelectFetchMore() {
     OrmQueryDetail detail = parse("select (id,name) fetch customer (email) fetch details.product (sku,description)");
 
     OrmQueryProperties root = detail.getChunk(null, false);
@@ -81,8 +76,7 @@ public class OrmQueryDetailParserTest extends BaseTestCase {
   }
 
   @Test
-  public void testParseWithPlusQuery() throws Exception {
-
+  public void testParseWithPlusQuery() {
     OrmQueryDetail detail = parse("select (id,name) fetch customer (+query,id,name,email)");
 
     OrmQueryProperties root = detail.getChunk(null, false);
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailTest.java
index 5c3ef69b6..189fd4457 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailTest.java
@@ -2,11 +2,11 @@ package io.ebeaninternal.server.querydefn;
 
 import io.ebean.BaseTestCase;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class OrmQueryDetailTest extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPlanKeyTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPlanKeyTest.java
similarity index 99%
rename from ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPlanKeyTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPlanKeyTest.java
index 305f9122b..e132f8320 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPlanKeyTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPlanKeyTest.java
@@ -9,7 +9,7 @@ import io.ebeaninternal.server.deploy.TableJoin;
 import io.ebeaninternal.server.deploy.meta.DeployTableJoin;
 import io.ebeaninternal.server.deploy.meta.DeployTableJoinColumn;
 import io.ebeaninternal.server.expression.BaseExpressionTest;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import java.sql.Timestamp;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesParserTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesParserTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesParserTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesParserTest.java
index a7c103b83..f15576f63 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesParserTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesParserTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.querydefn;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesTest.java
index 8df439a58..15dce130e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.querydefn;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.LinkedHashSet;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmUpdatePropertiesTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmUpdatePropertiesTest.java
similarity index 73%
rename from ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmUpdatePropertiesTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmUpdatePropertiesTest.java
index db534d131..da7e95299 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/querydefn/OrmUpdatePropertiesTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/querydefn/OrmUpdatePropertiesTest.java
@@ -1,8 +1,8 @@
 package io.ebeaninternal.server.querydefn;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class OrmUpdatePropertiesTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/ColumnMappingTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/ColumnMappingTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/rawsql/ColumnMappingTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/rawsql/ColumnMappingTest.java
index 86ec1cadd..ce793d8a7 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/ColumnMappingTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/ColumnMappingTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.rawsql;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/DRawSqlServiceTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/DRawSqlServiceTest.java
similarity index 84%
rename from ebean-core/src/test/java/io/ebeaninternal/server/rawsql/DRawSqlServiceTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/rawsql/DRawSqlServiceTest.java
index 58391ece3..a96af7b33 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/DRawSqlServiceTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/DRawSqlServiceTest.java
@@ -1,8 +1,8 @@
 package io.ebeaninternal.server.rawsql;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DRawSqlServiceTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/RawSqlKeyTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/RawSqlKeyTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/rawsql/RawSqlKeyTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/rawsql/RawSqlKeyTest.java
index 54efa28c5..b46714a99 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/RawSqlKeyTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/RawSqlKeyTest.java
@@ -3,7 +3,7 @@ package io.ebeaninternal.server.rawsql;
 
 import io.ebean.RawSql;
 import io.ebean.RawSqlBuilder;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilder.java b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilder.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilder.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilder.java
index 8d4feeaf9..84239ca9b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilder.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilder.java
@@ -1,18 +1,12 @@
 package io.ebeaninternal.server.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
-import io.ebean.SqlRow;
+import io.ebean.*;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.datasource.DataSourceConfig;
 import io.ebeaninternal.server.core.DefaultServer;
 import io.ebeaninternal.server.rawsql.SpiRawSql.Sql;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasicClob;
 import org.tests.model.basic.PersistentFileContent;
@@ -21,17 +15,13 @@ import org.tests.model.rawsql.ERawSqlAggBean;
 
 import javax.sql.DataSource;
 import java.nio.charset.StandardCharsets;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
+import java.sql.*;
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestRawSqlBuilder extends BaseTestCase {
 
@@ -74,7 +64,7 @@ public class TestRawSqlBuilder extends BaseTestCase {
 
     RawSql rawSql = RawSqlBuilder.parse("select\n id from\n o_customer").create();
 
-    Ebean.find(Customer.class)
+    DB.find(Customer.class)
       .setRawSql(rawSql)
       .findList();
   }
@@ -242,7 +232,7 @@ public class TestRawSqlBuilder extends BaseTestCase {
     assertEquals(2, columnMapping.getIndexPosition("scheduled"));
     assertEquals(3, columnMapping.getIndexPosition("completed"));
 
-    Query<ERawSqlAggBean> query = Ebean.find(ERawSqlAggBean.class)
+    Query<ERawSqlAggBean> query = DB.find(ERawSqlAggBean.class)
       .setRawSql(rawSql)
       .having().gt("total", 2)
       .query();
@@ -266,7 +256,7 @@ public class TestRawSqlBuilder extends BaseTestCase {
       "join o_customer c on o.kcustomer_id = c.id " +
       "where c.id = ? and o.id > ?";
 
-    final DataSource dataSource = DB.getDefault().getDataSource();
+    final DataSource dataSource = DB.getDefault().dataSource();
 
     try (Connection connection = dataSource.getConnection()) {
       try (PreparedStatement stmt = connection.prepareStatement(sql)) {
@@ -302,7 +292,7 @@ public class TestRawSqlBuilder extends BaseTestCase {
     final String sql = "select description from ebasic_clob where id = ?";
 
     List<SqlRow> rows = new ArrayList<>();
-    final DataSourceConfig config = ((DefaultServer) DB.getDefault()).getServerConfig().getDataSourceConfig();
+    final DataSourceConfig config = ((DefaultServer) DB.getDefault()).config().getDataSourceConfig();
 
     try (Connection connection = DriverManager.getConnection(config.getUrl(), config.getUsername(), config.getPassword());
          PreparedStatement stmt = connection.prepareStatement(sql)) {
@@ -327,7 +317,7 @@ public class TestRawSqlBuilder extends BaseTestCase {
     DB.save(pfc);
 
     List<SqlRow> rows = new ArrayList<>();
-    final DataSourceConfig config = ((DefaultServer) DB.getDefault()).getServerConfig().getDataSourceConfig();
+    final DataSourceConfig config = ((DefaultServer) DB.getDefault()).config().getDataSourceConfig();
 
     final String sql = "select content from persistent_file_content where id = ?";
     try (Connection connection = DriverManager.getConnection(config.getUrl(), config.getUsername(), config.getPassword());
diff --git a/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilderDistinct.java b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilderDistinct.java
new file mode 100644
index 000000000..7ea56e68f
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlBuilderDistinct.java
@@ -0,0 +1,24 @@
+package io.ebeaninternal.server.rawsql;
+
+import io.ebean.RawSql;
+import io.ebean.RawSqlBuilder;
+import io.ebeaninternal.server.rawsql.SpiRawSql.Sql;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+public class TestRawSqlBuilderDistinct {
+
+  @Test
+  public void testDistinct() {
+
+    RawSql r = RawSqlBuilder.parse("select distinct id, name from t_cust").create();
+    Sql sql = ((SpiRawSql)r).getSql();
+    assertEquals("id, name", sql.getPreFrom());
+    assertEquals("from t_cust", sql.getPreWhere());
+    assertEquals("", sql.getPreHaving());
+    assertNull(sql.getOrderBy());
+  }
+
+}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlColumnParsing.java b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlColumnParsing.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlColumnParsing.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlColumnParsing.java
index b9b5175db..6cf39f216 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlColumnParsing.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlColumnParsing.java
@@ -2,11 +2,11 @@ package io.ebeaninternal.server.rawsql;
 
 import io.ebeaninternal.server.rawsql.SpiRawSql.ColumnMapping;
 import io.ebeaninternal.server.rawsql.SpiRawSql.ColumnMapping.Column;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestRawSqlColumnParsing {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlParsing.java b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlParsing.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlParsing.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlParsing.java
index 8618431b1..70914dace 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlParsing.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlParsing.java
@@ -1,14 +1,10 @@
 package io.ebeaninternal.server.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
+import io.ebean.*;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
 import io.ebeaninternal.server.rawsql.SpiRawSql.Sql;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 import org.tests.rawsql.A2Customer;
@@ -17,7 +13,7 @@ import org.tests.rawsql.ACustomer;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestRawSqlParsing extends BaseTestCase {
 
@@ -37,7 +33,7 @@ public class TestRawSqlParsing extends BaseTestCase {
     Sql rs = ((SpiRawSql)rawSql).getSql();
 
     String s = rs.toString();
-    assertTrue(s, s.contains("[order_id, sum"));
+    assertTrue(s.contains("[order_id, sum"));
   }
 
   @Test
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlService.java b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlService.java
similarity index 99%
rename from ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlService.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlService.java
index 699e33ac7..5e2f415c5 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlService.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlService.java
@@ -2,7 +2,7 @@ package io.ebeaninternal.server.rawsql;
 
 import io.ebean.BaseTestCase;
 import io.ebean.SqlRow;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/text/json/DJsonScalarTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/text/json/DJsonScalarTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebeaninternal/server/text/json/DJsonScalarTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/text/json/DJsonScalarTest.java
index 1a5ef7fe1..a7a24f512 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/text/json/DJsonScalarTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/text/json/DJsonScalarTest.java
@@ -2,11 +2,11 @@ package io.ebeaninternal.server.text.json;
 
 import com.fasterxml.jackson.core.JsonFactory;
 import com.fasterxml.jackson.core.JsonGenerator;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebeaninternal.server.core.bootup.BootupClasses;
 import io.ebeaninternal.server.type.DefaultTypeManager;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.io.StringWriter;
@@ -22,8 +22,7 @@ public class DJsonScalarTest {
   private final DJsonScalar jsonScalar;
 
   public DJsonScalarTest() {
-
-    ServerConfig serverConfig = new ServerConfig();
+    DatabaseConfig serverConfig = new DatabaseConfig();
     serverConfig.setDatabasePlatform(new H2Platform());
     DefaultTypeManager typeManager = new DefaultTypeManager(serverConfig, new BootupClasses());
     jsonScalar = new DJsonScalar(typeManager);
@@ -31,7 +30,6 @@ public class DJsonScalarTest {
 
   @Test
   public void writeBasicTypes() throws IOException {
-
     StringWriter writer = new StringWriter();
     JsonGenerator generator = createGenerator(writer);
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/text/json/TestJsonWriteVisitor.java b/ebean-test/src/test/java/io/ebeaninternal/server/text/json/TestJsonWriteVisitor.java
similarity index 90%
rename from ebean-core/src/test/java/io/ebeaninternal/server/text/json/TestJsonWriteVisitor.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/text/json/TestJsonWriteVisitor.java
index bc065946a..054269e66 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/text/json/TestJsonWriteVisitor.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/text/json/TestJsonWriteVisitor.java
@@ -1,17 +1,13 @@
 package io.ebeaninternal.server.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
 import io.ebean.text.json.JsonWriteBeanVisitor;
 import io.ebean.text.json.JsonWriteOptions;
 import io.ebean.text.json.JsonWriter;
-import org.tests.model.basic.Address;
-import org.tests.model.basic.Contact;
-import org.tests.model.basic.Country;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.math.BigDecimal;
 import java.util.List;
@@ -25,7 +21,7 @@ public class TestJsonWriteVisitor extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class)
+    List<Customer> list = DB.find(Customer.class)
       .select("id, name, status")
       .fetch("billingAddress", "line1, city")
       .fetch("billingAddress.country", "*")
@@ -33,7 +29,7 @@ public class TestJsonWriteVisitor extends BaseTestCase {
       .order().desc("id")
       .findList();
 
-    JsonContext json = Ebean.json();
+    JsonContext json = DB.json();
 
     JsonWriteOptions options = new JsonWriteOptions();
     options.setRootPathVisitor(new CustomerVisitor());
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/text/json/TestTextJsonBeanReadVisitor.java b/ebean-test/src/test/java/io/ebeaninternal/server/text/json/TestTextJsonBeanReadVisitor.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebeaninternal/server/text/json/TestTextJsonBeanReadVisitor.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/text/json/TestTextJsonBeanReadVisitor.java
index b557f6b45..682e76363 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/text/json/TestTextJsonBeanReadVisitor.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/text/json/TestTextJsonBeanReadVisitor.java
@@ -1,21 +1,21 @@
 package io.ebeaninternal.server.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
 import io.ebean.text.json.JsonReadBeanVisitor;
 import io.ebean.text.json.JsonReadOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.io.StringReader;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestTextJsonBeanReadVisitor extends BaseTestCase {
 
@@ -25,7 +25,7 @@ public class TestTextJsonBeanReadVisitor extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class)
+    List<Customer> list = DB.find(Customer.class)
       .select("id, name, status, shippingAddress")
       .fetch("billingAddress", "line1, city")
       .fetch("billingAddress.country", "*")
@@ -33,7 +33,7 @@ public class TestTextJsonBeanReadVisitor extends BaseTestCase {
       .order().desc("id")
       .findList();
 
-    JsonContext json = Ebean.json();
+    JsonContext json = DB.json();
 
     JsonReadOptions options = new JsonReadOptions();
     options.addRootVisitor(new CVisitor());
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/text/json/WriteJsonDirtyTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/text/json/WriteJsonDirtyTest.java
similarity index 77%
rename from ebean-core/src/test/java/io/ebeaninternal/server/text/json/WriteJsonDirtyTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/text/json/WriteJsonDirtyTest.java
index 6d7e6e597..faf74d993 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/text/json/WriteJsonDirtyTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/text/json/WriteJsonDirtyTest.java
@@ -1,21 +1,21 @@
 package io.ebeaninternal.server.text.json;
 
-import io.ebean.Ebean;
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonGenerator;
+import io.ebean.DB;
 import io.ebean.bean.EntityBean;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import com.fasterxml.jackson.core.JsonFactory;
-import com.fasterxml.jackson.core.JsonGenerator;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.io.StringWriter;
 import java.sql.Date;
 import java.util.List;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class WriteJsonDirtyTest {
 
@@ -23,14 +23,14 @@ public class WriteJsonDirtyTest {
   public void test() throws IOException {
 
     ResetBasicData.reset();
-    List<Customer> customers = Ebean.find(Customer.class).findList();
+    List<Customer> customers = DB.find(Customer.class).findList();
 
-    Customer customer = Ebean.find(Customer.class).setId(customers.get(0).getId())
+    Customer customer = DB.find(Customer.class).setId(customers.get(0).getId())
       .setUseCache(false)
       .findOne();
 
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
-    BeanDescriptor<Customer> descriptor = server.getBeanDescriptor(Customer.class);
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
+    BeanDescriptor<Customer> descriptor = server.descriptor(Customer.class);
 
     customer.setName("dirtyCustName");
     customer.setAnniversary(new Date(System.currentTimeMillis()));
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/text/json/WriteJsonTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/text/json/WriteJsonTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/text/json/WriteJsonTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/text/json/WriteJsonTest.java
index e7950dfbc..ec9514c72 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/text/json/WriteJsonTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/text/json/WriteJsonTest.java
@@ -4,7 +4,7 @@ import io.ebean.DB;
 import io.ebean.FetchPath;
 import io.ebean.Query;
 import io.ebean.text.PathProperties;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/DefaultPersistenceContextTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/DefaultPersistenceContextTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/transaction/DefaultPersistenceContextTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/transaction/DefaultPersistenceContextTest.java
index 87dbf4fa3..4983c31e3 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/DefaultPersistenceContextTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/DefaultPersistenceContextTest.java
@@ -2,16 +2,12 @@ package io.ebeaninternal.server.transaction;
 
 import io.ebean.bean.PersistenceContext;
 import io.ebeaninternal.server.deploy.PersistenceContextUtil;
-import org.junit.Test;
-import org.tests.model.basic.Car;
-import org.tests.model.basic.Contact;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Product;
-import org.tests.model.basic.Vehicle;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class DefaultPersistenceContextTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/DefaultProfileHandlerTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/DefaultProfileHandlerTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/server/transaction/DefaultProfileHandlerTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/transaction/DefaultProfileHandlerTest.java
index 0a6ee1e3a..758ee8964 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/DefaultProfileHandlerTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/DefaultProfileHandlerTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.transaction;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class DefaultProfileHandlerTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/DefaultTransactionThreadLocalTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/DefaultTransactionThreadLocalTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/server/transaction/DefaultTransactionThreadLocalTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/transaction/DefaultTransactionThreadLocalTest.java
index 0f3da4105..9fe2386c7 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/DefaultTransactionThreadLocalTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/DefaultTransactionThreadLocalTest.java
@@ -1,23 +1,17 @@
 package io.ebeaninternal.server.transaction;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.Database;
-import io.ebean.DatabaseFactory;
-import io.ebean.Transaction;
+import io.ebean.*;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.config.DatabaseConfig;
 import io.ebeaninternal.api.SpiTransaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 import org.tests.model.basic.UTDetail;
 import org.tests.model.basic.UTMaster;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class DefaultTransactionThreadLocalTest extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/JdbcTransactionTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/JdbcTransactionTest.java
similarity index 80%
rename from ebean-core/src/test/java/io/ebeaninternal/server/transaction/JdbcTransactionTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/transaction/JdbcTransactionTest.java
index 7416ca58b..ac3eeacf9 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/JdbcTransactionTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/JdbcTransactionTest.java
@@ -5,7 +5,7 @@ import io.ebean.Transaction;
 import io.ebean.TransactionCallbackAdapter;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheManager;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasic;
@@ -43,19 +43,19 @@ public class JdbcTransactionTest {
   @Test
   public void skipCacheAfterSave() {
 
-    ServerCacheManager cacheManager = DB.getDefault().getServerCacheManager();
-    ServerCache customerBeanCache = cacheManager.getBeanCache(Customer.class);
-    ServerCache contactNatKeyCache = cacheManager.getNaturalKeyCache(Contact.class);
+    ServerCacheManager cacheManager = DB.getDefault().cacheManager();
+    ServerCache customerBeanCache = cacheManager.beanCache(Customer.class);
+    ServerCache contactNatKeyCache = cacheManager.naturalKeyCache(Contact.class);
 
     try (Transaction transaction = DB.beginTransaction()) {
-      customerBeanCache.getStatistics(true);
-      contactNatKeyCache.getStatistics(true);
+      customerBeanCache.statistics(true);
+      contactNatKeyCache.statistics(true);
 
       Customer.find.byId(19898989);
       DB.find(Contact.class).where().eq("email", "junk@foo.com").findOne();
 
-      assertThat(customerBeanCache.getStatistics(true).getMissCount()).isEqualTo(1);
-      assertThat(contactNatKeyCache.getStatistics(true).getMissCount()).isEqualTo(1);
+      assertThat(customerBeanCache.statistics(true).getMissCount()).isEqualTo(1);
+      assertThat(contactNatKeyCache.statistics(true).getMissCount()).isEqualTo(1);
 
       EBasic basic = new EBasic("b1");
       DB.save(basic);
@@ -64,8 +64,8 @@ public class JdbcTransactionTest {
       Customer.find.byId(29898989);
       DB.find(Contact.class).where().eq("email", "junk2@foo.com").findOne();
 
-      assertThat(customerBeanCache.getStatistics(true).getMissCount()).isEqualTo(0);
-      assertThat(contactNatKeyCache.getStatistics(true).getMissCount()).isEqualTo(0);
+      assertThat(customerBeanCache.statistics(true).getMissCount()).isEqualTo(0);
+      assertThat(contactNatKeyCache.statistics(true).getMissCount()).isEqualTo(0);
     }
   }
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/RemoteTransactionEventTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/RemoteTransactionEventTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/transaction/RemoteTransactionEventTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/transaction/RemoteTransactionEventTest.java
index bea6709f2..db62950e7 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/RemoteTransactionEventTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/RemoteTransactionEventTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.transaction;
 
 import io.ebeaninternal.server.cache.RemoteCacheEvent;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
 import java.util.HashSet;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/TableModStateTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/TableModStateTest.java
similarity index 87%
rename from ebean-core/src/test/java/io/ebeaninternal/server/transaction/TableModStateTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/transaction/TableModStateTest.java
index f2ab59bd9..26acfc183 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/TableModStateTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/TableModStateTest.java
@@ -1,13 +1,13 @@
 package io.ebeaninternal.server.transaction;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TableModStateTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/TransactionManagerTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/TransactionManagerTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/transaction/TransactionManagerTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/transaction/TransactionManagerTest.java
index da624fdbb..62f89784a 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/transaction/TransactionManagerTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/transaction/TransactionManagerTest.java
@@ -1,14 +1,14 @@
 package io.ebeaninternal.server.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.TxScope;
 import io.ebeaninternal.api.ScopedTransaction;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.SpiTransaction;
 import io.ebeaninternal.api.SpiTransactionManager;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Customer;
@@ -28,7 +28,7 @@ public class TransactionManagerTest extends BaseTestCase {
 
     SpiEbeanServer server = spiEbeanServer();
 
-    SpiTransactionManager transactionManager = server.getTransactionManager();
+    SpiTransactionManager transactionManager = server.transactionManager();
 
     DataSource dataSource = transactionManager.getDataSource();
     Connection connection = dataSource.getConnection();
@@ -44,7 +44,7 @@ public class TransactionManagerTest extends BaseTestCase {
       Customer.find.byName("In external");
 
       log.info("inner begin");
-      Transaction inner = Ebean.beginTransaction();
+      Transaction inner = DB.beginTransaction();
       try {
 
         current = Transaction.current();
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/BasePlatformArrayTypeFactoryTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/BasePlatformArrayTypeFactoryTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/BasePlatformArrayTypeFactoryTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/BasePlatformArrayTypeFactoryTest.java
index aca97f3ca..3e09e8b22 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/BasePlatformArrayTypeFactoryTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/BasePlatformArrayTypeFactoryTest.java
@@ -5,7 +5,7 @@ import org.postgresql.util.PGobject;
 
 import java.sql.SQLException;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class BasePlatformArrayTypeFactoryTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressTest.java
index 83c7ad3e5..73f869f1a 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressTest.java
@@ -1,10 +1,10 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.net.InetAddress;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ConvertInetAddressTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressesTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressesTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressesTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressesTest.java
index 0c78eb178..a2177d243 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressesTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ConvertInetAddressesTest.java
@@ -1,10 +1,10 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.net.InetAddress;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ConvertInetAddressesTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/DecimalUtilsTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/DecimalUtilsTest.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/DecimalUtilsTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/DecimalUtilsTest.java
index d90cfb26e..7a7d19dd3 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/DecimalUtilsTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/DecimalUtilsTest.java
@@ -1,13 +1,13 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.math.BigDecimal;
 import java.sql.Timestamp;
 import java.time.Duration;
 import java.time.Instant;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class DecimalUtilsTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/DefaultTypeFactoryTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/DefaultTypeFactoryTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/DefaultTypeFactoryTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/DefaultTypeFactoryTest.java
index e023c9d7d..0a0a6c0b2 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/DefaultTypeFactoryTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/DefaultTypeFactoryTest.java
@@ -1,11 +1,11 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.core.type.ScalarType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Types;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 
 public class DefaultTypeFactoryTest {
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/DefaultTypeManagerTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/DefaultTypeManagerTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/DefaultTypeManagerTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/DefaultTypeManagerTest.java
index 950a805fd..797c66e7d 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/DefaultTypeManagerTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/DefaultTypeManagerTest.java
@@ -4,7 +4,7 @@ import io.ebean.config.DatabaseConfig;
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
 import io.ebean.core.type.ScalarType;
 import io.ebeaninternal.server.core.bootup.BootupClasses;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.array.IntEnum;
 import org.tests.model.array.VarcharEnum;
 import org.tests.model.basic.Car;
@@ -14,8 +14,8 @@ import java.time.DayOfWeek;
 import java.time.Month;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class DefaultTypeManagerTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/IsoJsonDateTimeParserTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/IsoJsonDateTimeParserTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/IsoJsonDateTimeParserTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/IsoJsonDateTimeParserTest.java
index 79e3f1ef4..75e600ee6 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/IsoJsonDateTimeParserTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/IsoJsonDateTimeParserTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.time.Instant;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/JsonTester.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/JsonTester.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/JsonTester.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/JsonTester.java
index b50efaad2..8db4b633e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/JsonTester.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/JsonTester.java
@@ -11,7 +11,7 @@ import io.ebeaninternal.server.text.json.WriteJson;
 import java.io.IOException;
 import java.io.StringWriter;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * Base class to help json testing.
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/JsonTrimTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/JsonTrimTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/JsonTrimTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/JsonTrimTest.java
index 622ceb3f7..c08ceeab7 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/JsonTrimTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/JsonTrimTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareFlagTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareFlagTest.java
similarity index 79%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareFlagTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareFlagTest.java
index 3674a261c..2b774b9d3 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareFlagTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareFlagTest.java
@@ -1,13 +1,9 @@
 package io.ebeaninternal.server.type;
 
 import io.ebeaninternal.json.ModifyAwareFlag;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
+import java.io.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareListTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareListTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareListTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareListTest.java
index a7ebbecda..52180f322 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareListTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareListTest.java
@@ -2,21 +2,13 @@ package io.ebeaninternal.server.type;
 
 import io.ebeaninternal.json.ModifyAwareList;
 import io.ebeaninternal.json.ModifyAwareSet;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ListIterator;
+import java.io.*;
+import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 
 public class ModifyAwareListTest {
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareMapTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareMapTest.java
similarity index 92%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareMapTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareMapTest.java
index 3c0a9bdf9..18bcaad5a 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareMapTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareMapTest.java
@@ -1,13 +1,9 @@
 package io.ebeaninternal.server.type;
 
 import io.ebeaninternal.json.ModifyAwareMap;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
+import java.io.*;
 import java.util.HashMap;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareSetTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareSetTest.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareSetTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareSetTest.java
index abb8a4e2e..5e6fe9e49 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ModifyAwareSetTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ModifyAwareSetTest.java
@@ -1,13 +1,9 @@
 package io.ebeaninternal.server.type;
 
 import io.ebeaninternal.json.ModifyAwareSet;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
+import java.io.*;
 import java.util.Arrays;
 import java.util.HashSet;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListH2Test.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListH2Test.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListH2Test.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListH2Test.java
index b23a2126d..ad1f1d44c 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListH2Test.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListH2Test.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.SQLException;
 import java.util.UUID;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListTest.java
index 13496e407..1da2f5773 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArrayListTest.java
@@ -6,13 +6,15 @@ import io.ebean.DB;
 import io.ebean.core.type.DataReader;
 import io.ebean.core.type.ScalarType;
 import io.ebean.text.json.EJson;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
 import java.io.IOException;
 import java.io.StringReader;
 import java.sql.SQLException;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetH2Test.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetH2Test.java
similarity index 99%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetH2Test.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetH2Test.java
index ece3a122b..d8c2ea53d 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetH2Test.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetH2Test.java
@@ -4,7 +4,7 @@ import com.fasterxml.jackson.core.JsonParser;
 import io.ebean.DB;
 import io.ebean.core.type.ScalarType;
 import io.ebean.text.json.EJson;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.io.StringReader;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetTest.java
index 1fa9732d7..b5e162d0e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeArraySetTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.SQLException;
 import java.util.UUID;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeBooleanTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeBooleanTest.java
similarity index 82%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeBooleanTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeBooleanTest.java
index 5c4c83ea5..fcbe7b535 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeBooleanTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeBooleanTest.java
@@ -1,21 +1,19 @@
 package io.ebeaninternal.server.type;
 
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TOne;
-import org.junit.Test;
 
 import java.sql.Types;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeBooleanTest {
 
-  JsonContext jsonContext = Ebean.getDefaultServer().json();
+  JsonContext jsonContext = DB.getDefault().json();
 
   @Test
   public void json_true() {
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeCalendarTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeCalendarTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeCalendarTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeCalendarTest.java
index 922beadeb..4edc4c059 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeCalendarTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeCalendarTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.config.JsonConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Types;
 import java.util.Calendar;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeDateTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeDateTest.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeDateTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeDateTest.java
index e69a4ce2c..caa293a6b 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeDateTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeDateTest.java
@@ -1,13 +1,13 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.config.JsonConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.sql.Date;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ScalarTypeDateTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationTest.java
index c9173d58f..1a57f6080 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.text.TextException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -9,7 +9,7 @@ import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.time.Duration;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeDurationTest {
 
@@ -75,22 +75,19 @@ public class ScalarTypeDurationTest {
   }
 
   @Test
-  public void testParse() throws Exception {
-
+  public void testParse() {
     Duration duration = type.parse("PT20M34S");
     assertEquals(Duration.ofSeconds(1234), duration);
   }
 
   @Test
-  public void testIsDateTimeCapable() throws Exception {
-
+  public void testIsDateTimeCapable() {
     assertFalse(type.isDateTimeCapable());
   }
 
-  @Test(expected = TextException.class)
-  public void testConvertFromMillis() throws Exception {
-
-    type.convertFromMillis(1000);
+  @Test
+  public void testConvertFromMillis() {
+    assertThrows(TextException.class, () -> type.convertFromMillis(1000));
   }
 
   @Test
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationWithNanosTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationWithNanosTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationWithNanosTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationWithNanosTest.java
index f3fd9ff62..60e4ffe29 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationWithNanosTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeDurationWithNanosTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.text.TextException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -10,7 +10,7 @@ import java.io.ObjectOutputStream;
 import java.math.BigDecimal;
 import java.time.Duration;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeDurationWithNanosTest {
 
@@ -74,28 +74,24 @@ public class ScalarTypeDurationWithNanosTest {
   }
 
   @Test
-  public void testParse() throws Exception {
-
+  public void testParse() {
     Duration duration = Duration.ofSeconds(323, 1500000);
     Duration val1 = type.parse("PT5M23.0015S");
     assertEquals(duration, val1);
   }
 
   @Test
-  public void testIsDateTimeCapable() throws Exception {
-
+  public void testIsDateTimeCapable() {
     assertFalse(type.isDateTimeCapable());
   }
 
-  @Test(expected = TextException.class)
-  public void testConvertFromMillis() throws Exception {
-
-    type.convertFromMillis(1000);
+  @Test
+  public void testConvertFromMillis() {
+    assertThrows(TextException.class, () -> type.convertFromMillis(1000));
   }
 
   @Test
   public void testJsonRead() throws Exception {
-
     Duration duration = Duration.ofSeconds(323, 1500000);
 
     JsonTester<Duration> jsonTester = new JsonTester<>(type);
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeInstantTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeInstantTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeInstantTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeInstantTest.java
index 07ecd0867..c40950842 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeInstantTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeInstantTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.config.JsonConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -11,9 +11,7 @@ import java.sql.Timestamp;
 import java.time.Instant;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeInstantTest {
 
diff --git a/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeIntegerTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeIntegerTest.java
new file mode 100644
index 000000000..ba292a20a
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeIntegerTest.java
@@ -0,0 +1,22 @@
+package io.ebeaninternal.server.type;
+
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ScalarTypeIntegerTest {
+
+  private final ScalarTypeInteger type = new ScalarTypeInteger();
+
+  @Test
+  public void format_when_string() {
+    assertThat(type.format("1")).isEqualTo("1");
+  }
+
+  @Test
+  public void format_when_integer() {
+    assertThat(type.format(1)).isEqualTo("1");
+  }
+
+}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTest.java
similarity index 98%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTest.java
index 250356338..0d3719f8a 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTest.java
@@ -2,7 +2,7 @@ package io.ebeaninternal.server.type;
 
 import io.ebean.config.JsonConfig;
 import org.joda.time.LocalDate;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.sql.Date;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTimeTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTimeTest.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTimeTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTimeTest.java
index 3c8205602..933176623 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTimeTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalDateTimeTest.java
@@ -3,11 +3,11 @@ package io.ebeaninternal.server.type;
 import io.ebean.config.JsonConfig;
 import org.joda.time.DateTimeZone;
 import org.joda.time.LocalDateTime;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ScalarTypeJodaLocalDateTimeTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalTimeTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalTimeTest.java
similarity index 86%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalTimeTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalTimeTest.java
index 64d3d93aa..80918a5a2 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalTimeTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaLocalTimeTest.java
@@ -1,16 +1,16 @@
 package io.ebeaninternal.server.type;
 
-import io.ebean.Ebean;
-import org.tests.model.basic.TJodaEntity;
+import io.ebean.DB;
 import org.joda.time.DateTimeZone;
 import org.joda.time.LocalDateTime;
 import org.joda.time.LocalTime;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.TJodaEntity;
 
 import java.sql.Timestamp;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ScalarTypeJodaLocalTimeTest {
 
@@ -55,8 +55,8 @@ public class ScalarTypeJodaLocalTimeTest {
     bean.setId(42);
     bean.setLocalTime(now);
 
-    String json = Ebean.json().toJson(bean);
-    TJodaEntity bean1 = Ebean.json().toBean(TJodaEntity.class, json);
+    String json = DB.json().toJson(bean);
+    TJodaEntity bean1 = DB.json().toBean(TJodaEntity.class, json);
 
     assertEquals(bean1.getLocalTime(), now);
   }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaPeriodTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaPeriodTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaPeriodTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaPeriodTest.java
index 3a58e9fbf..aafbe3a92 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaPeriodTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJodaPeriodTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import org.joda.time.Period;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJsonListTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJsonListTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJsonListTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJsonListTest.java
index 43ed867ba..27d8a7698 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeJsonListTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeJsonListTest.java
@@ -2,7 +2,7 @@ package io.ebeaninternal.server.type;
 
 import io.ebean.config.dbplatform.ExtraDbTypes;
 import io.ebean.core.type.DocPropertyType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.SQLException;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTest.java
similarity index 91%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTest.java
index b76c5cad3..076bad958 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTest.java
@@ -1,15 +1,15 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.config.JsonConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.sql.Date;
 import java.time.LocalDate;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class ScalarTypeLocalDateTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTimeTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTimeTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTimeTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTimeTest.java
index 65423e012..623402fb7 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTimeTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalDateTimeTest.java
@@ -3,14 +3,14 @@ package io.ebeaninternal.server.type;
 import com.fasterxml.jackson.core.JsonFactory;
 import com.fasterxml.jackson.core.JsonGenerator;
 import io.ebean.config.JsonConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.StringWriter;
 import java.sql.Timestamp;
 import java.time.LocalDateTime;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeLocalDateTimeTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeTest.java
index c2e73356f..e98cdef0f 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.text.TextException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -10,7 +10,7 @@ import java.io.ObjectOutputStream;
 import java.sql.Time;
 import java.time.LocalTime;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeLocalTimeTest {
 
@@ -71,28 +71,24 @@ public class ScalarTypeLocalTimeTest {
   }
 
   @Test
-  public void testParse() throws Exception {
-
+  public void testParse() {
     LocalTime localTime = LocalTime.of(9, 23, 45);
     LocalTime val1 = type.parse("09:23:45");
     assertEquals(localTime, val1);
   }
 
   @Test
-  public void testIsDateTimeCapable() throws Exception {
-
+  public void testIsDateTimeCapable() {
     assertFalse(type.isDateTimeCapable());
   }
 
-  @Test(expected = TextException.class)
-  public void testConvertFromMillis() throws Exception {
-
-    type.convertFromMillis(1234);
+  @Test
+  public void testConvertFromMillis() {
+    assertThrows(TextException.class, () -> type.convertFromMillis(1234));
   }
 
   @Test
   public void testJsonRead() throws Exception {
-
     LocalTime localTime = LocalTime.of(9, 23, 45);
 
     JsonTester<LocalTime> jsonTester = new JsonTester<>(type);
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeWithNanosTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeWithNanosTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeWithNanosTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeWithNanosTest.java
index a415a0dd7..6e2e24057 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeWithNanosTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLocalTimeWithNanosTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.text.TextException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -9,7 +9,7 @@ import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.time.LocalTime;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeLocalTimeWithNanosTest {
 
@@ -62,36 +62,30 @@ public class ScalarTypeLocalTimeWithNanosTest {
 
   @Test
   public void testFormatValue() throws Exception {
-
     LocalTime localTime = LocalTime.of(9, 23, 45);
     String formatted = type.formatValue(localTime);
     assertEquals("09:23:45", formatted);
   }
 
   @Test
-  public void testParse() throws Exception {
-
+  public void testParse() {
     LocalTime localTime = LocalTime.of(9, 23, 45);
     LocalTime val1 = type.parse("09:23:45");
     assertEquals(localTime, val1);
   }
 
   @Test
-  public void testIsDateTimeCapable() throws Exception {
-
+  public void testIsDateTimeCapable() {
     assertFalse(type.isDateTimeCapable());
   }
 
-  @Test(expected = TextException.class)
-  public void testConvertFromMillis() throws Exception {
-
-    type.convertFromMillis(1234);
+  @Test
+  public void testConvertFromMillis() {
+    assertThrows(TextException.class, () -> type.convertFromMillis(1234));
   }
 
   @Test
   public void testJsonRead() throws Exception {
-
-
     LocalTime localTime = LocalTime.of(9, 23, 45);
 
     JsonTester<LocalTime> jsonTester = new JsonTester<>(type);
diff --git a/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLongTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLongTest.java
new file mode 100644
index 000000000..dbf3c3815
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeLongTest.java
@@ -0,0 +1,22 @@
+package io.ebeaninternal.server.type;
+
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ScalarTypeLongTest {
+
+  private final ScalarTypeLong type = new ScalarTypeLong();
+
+  @Test
+  public void format_when_string() {
+    assertThat(type.format("1")).isEqualTo("1");
+  }
+
+  @Test
+  public void format_when_long() {
+    assertThat(type.format(1L)).isEqualTo("1");
+  }
+
+}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeMonthDayTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeMonthDayTest.java
similarity index 75%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeMonthDayTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeMonthDayTest.java
index 83f28acd3..efe128b91 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeMonthDayTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeMonthDayTest.java
@@ -1,13 +1,12 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Date;
 import java.time.LocalDate;
 import java.time.MonthDay;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeMonthDayTest {
 
@@ -40,8 +39,7 @@ public class ScalarTypeMonthDayTest {
   }
 
   @Test
-  public void testFormatParse() throws Exception {
-
+  public void testFormatParse() {
     MonthDay value = MonthDay.of(4, 29);
     String val1 = type.formatValue(value);
     MonthDay monthDay = type.parse(val1);
@@ -50,27 +48,21 @@ public class ScalarTypeMonthDayTest {
     assertEquals(value, monthDay);
   }
 
-
   @Test
-  public void testIsDateTimeCapable() throws Exception {
+  public void testIsDateTimeCapable() {
     assertFalse(type.isDateTimeCapable());
   }
 
-  @Test(expected = RuntimeException.class)
-  public void testConvertFromMillis() throws Exception {
-    type.convertFromMillis(1203);
+  @Test
+  public void testConvertFromMillis() {
+    assertThrows(RuntimeException.class, () -> type.convertFromMillis(1203));
   }
 
   @Test
   public void testJson() throws Exception {
-
     MonthDay value = MonthDay.of(4, 29);
     JsonTester<MonthDay> jsonTester = new JsonTester<>(type);
     jsonTester.test(value);
   }
 
-  @Test
-  public void testReadWriteData() throws Exception {
-
-  }
 }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetDateTimeTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetDateTimeTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetDateTimeTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetDateTimeTest.java
index b0b2b1eb0..835546e1a 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetDateTimeTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetDateTimeTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.config.JsonConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 import java.time.OffsetDateTime;
@@ -9,9 +9,7 @@ import java.time.ZoneOffset;
 import java.util.TimeZone;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeOffsetDateTimeTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetTimeTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetTimeTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetTimeTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetTimeTest.java
index a4dbe0bcc..a5aabbe7e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetTimeTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeOffsetTimeTest.java
@@ -1,10 +1,10 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.time.OffsetTime;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ScalarTypeOffsetTimeTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypePathTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypePathTest.java
similarity index 89%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypePathTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypePathTest.java
index 549004463..1f4616061 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypePathTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypePathTest.java
@@ -1,12 +1,12 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.File;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ScalarTypePathTest {
   private static final String TEMP_PATH = new File("/tmp").getAbsolutePath();
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypePeriodTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypePeriodTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypePeriodTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypePeriodTest.java
index 858c2d10d..29d6e6767 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypePeriodTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypePeriodTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.time.Period;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypePostgresHstoreTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypePostgresHstoreTest.java
similarity index 84%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypePostgresHstoreTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypePostgresHstoreTest.java
index 7ca187dc2..382cd1db0 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypePostgresHstoreTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypePostgresHstoreTest.java
@@ -5,7 +5,7 @@ import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.JsonParser;
 import com.fasterxml.jackson.core.JsonToken;
 import io.ebeaninternal.json.ModifyAwareMap;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.io.StringWriter;
@@ -13,7 +13,7 @@ import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypePostgresHstoreTest {
 
@@ -22,17 +22,17 @@ public class ScalarTypePostgresHstoreTest {
   JsonFactory jsonFactory = new JsonFactory();
 
   @Test
-  public void testIsMutable() throws Exception {
+  public void testIsMutable() {
     assertTrue(hstore.isMutable());
   }
 
   @Test
-  public void testIsDateTimeCapable() throws Exception {
+  public void testIsDateTimeCapable() {
     assertFalse(hstore.isDateTimeCapable());
   }
 
   @Test
-  public void testIsDirty() throws Exception {
+  public void testIsDirty() {
     Map<String, Object> emptyMap = new HashMap<>();
     assertTrue(hstore.isDirty(emptyMap));
 
@@ -44,25 +44,25 @@ public class ScalarTypePostgresHstoreTest {
 
   @Test
   @SuppressWarnings("unchecked")
-  public void testParse() throws Exception {
+  public void testParse() {
     Map<String, Object> map = (Map<String, Object>) hstore.parse("{\"name\":\"rob\"}");
     assertEquals(1, map.size());
     assertEquals("rob", map.get("name"));
   }
 
-  @Test(expected = RuntimeException.class)
+  @Test
   @SuppressWarnings("unchecked")
-  public void testParseDateTime() throws Exception {
-    Map<String, Object> map = (Map<String, Object>) hstore.convertFromMillis(1234L);
-    assertEquals(1, map.size());
-    assertEquals("rob", map.get("name"));
+  public void testParseDateTime() {
+    assertThrows(RuntimeException.class, () -> {
+      Map<String, Object> map = (Map<String, Object>) hstore.convertFromMillis(1234L);
+      assertEquals(1, map.size());
+      assertEquals("rob", map.get("name"));
+    });
   }
 
   @Test
   public void testJsonWrite() throws Exception {
-
     Map<String, Object> map = new LinkedHashMap<>();
-
     assertEquals("{\"key\":{}}", generateJson(map));
 
     map.put("name", "rob");
@@ -74,7 +74,6 @@ public class ScalarTypePostgresHstoreTest {
 
   @Test
   public void testJsonRead() throws Exception {
-
     Map<String, Object> map = parseHstore("{\"name\":\"rob\"}");
     assertEquals(1, map.size());
     assertEquals("rob", map.get("name"));
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeTimestampTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeTimestampTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeTimestampTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeTimestampTest.java
index b2fb2599e..9c9412025 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeTimestampTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeTimestampTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.config.JsonConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 
diff --git a/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeUUIDBaseTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeUUIDBaseTest.java
new file mode 100644
index 000000000..29cdef05d
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeUUIDBaseTest.java
@@ -0,0 +1,23 @@
+package io.ebeaninternal.server.type;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ScalarTypeUUIDBaseTest {
+
+  private final ScalarTypeUUIDBase type = new ScalarTypeUUIDNative();
+  private final UUID uuid = UUID.randomUUID();
+
+  @Test
+  public void format_as_uuid() {
+    assertThat(type.format(uuid)).isEqualTo(uuid.toString());
+  }
+
+  @Test
+  public void format_as_String() {
+    assertThat(type.format(uuid.toString())).isEqualTo(uuid.toString());
+  }
+}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeUtilDateTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeUtilDateTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeUtilDateTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeUtilDateTest.java
index b39e8d347..b8e1149e9 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeUtilDateTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeUtilDateTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.config.JsonConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.util.Date;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperAdapterTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperAdapterTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperAdapterTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperAdapterTest.java
index 1f79db003..bd085d73a 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperAdapterTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperAdapterTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import javax.persistence.AttributeConverter;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperOidTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperOidTest.java
similarity index 96%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperOidTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperOidTest.java
index cb602e7f2..d84371df9 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperOidTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeWrapperOidTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.ivo.Oid;
 import org.tests.model.ivo.converter.OidTypeConverter;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearMonthDateTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearMonthDateTest.java
similarity index 95%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearMonthDateTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearMonthDateTest.java
index ec0979bd6..d2af88cae 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearMonthDateTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearMonthDateTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.config.JsonConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.sql.Date;
@@ -11,7 +11,7 @@ import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ScalarTypeYearMonthDateTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearTest.java
similarity index 86%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearTest.java
index be37fb162..c37282744 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeYearTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.text.TextException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -9,7 +9,7 @@ import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.time.Year;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeYearTest {
 
@@ -64,33 +64,28 @@ public class ScalarTypeYearTest {
 
   @Test
   public void testFormatValue() throws Exception {
-
     String formatted = type.formatValue(Year.of(2013));
     assertEquals("2013", formatted);
   }
 
   @Test
-  public void testParse() throws Exception {
-
+  public void testParse() {
     Year year = type.parse("2013");
     assertEquals(Year.of(2013), year);
   }
 
   @Test
-  public void testIsDateTimeCapable() throws Exception {
-
+  public void testIsDateTimeCapable() {
     assertFalse(type.isDateTimeCapable());
   }
 
-  @Test(expected = TextException.class)
-  public void testConvertFromMillis() throws Exception {
-
-    type.convertFromMillis(1000);
+  @Test
+  public void testConvertFromMillis() {
+    assertThrows(TextException.class, () -> type.convertFromMillis(1000));
   }
 
   @Test
   public void testJson() throws Exception {
-
     JsonTester<Year> jsonTester = new JsonTester<>(type);
     jsonTester.test(Year.of(2013));
   }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneIdTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneIdTest.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneIdTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneIdTest.java
index a48ed0427..4dfbfd886 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneIdTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneIdTest.java
@@ -1,10 +1,10 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.time.ZoneId;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ScalarTypeZoneIdTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneOffsetTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneOffsetTest.java
similarity index 90%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneOffsetTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneOffsetTest.java
index 65b544f5f..be581d818 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneOffsetTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeZoneOffsetTest.java
@@ -1,12 +1,12 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.time.ZoneId;
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ScalarTypeZoneOffsetTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeZonedDateTimeTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeZonedDateTimeTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeZonedDateTimeTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeZonedDateTimeTest.java
index 168041723..f7942b397 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/ScalarTypeZonedDateTimeTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/ScalarTypeZonedDateTimeTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.config.JsonConfig;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 import java.time.OffsetDateTime;
@@ -11,7 +11,7 @@ import java.time.ZonedDateTime;
 import java.util.TimeZone;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ScalarTypeZonedDateTimeTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/TestBinaryUUID.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestBinaryUUID.java
similarity index 89%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/TestBinaryUUID.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/TestBinaryUUID.java
index 69dc36751..b96c190f7 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/TestBinaryUUID.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestBinaryUUID.java
@@ -3,14 +3,14 @@ package io.ebeaninternal.server.type;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.SqlRow;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UUOne;
 
 import java.util.List;
 import java.util.UUID;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestBinaryUUID extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/TestEnumToBeanType.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestEnumToBeanType.java
similarity index 82%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/TestEnumToBeanType.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/TestEnumToBeanType.java
index 366adcc58..10596b7f2 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/TestEnumToBeanType.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestEnumToBeanType.java
@@ -2,10 +2,11 @@ package io.ebeaninternal.server.type;
 
 import io.ebeaninternal.server.type.ScalarTypeEnumStandard.OrdinalEnum;
 import io.ebeaninternal.server.type.ScalarTypeEnumStandard.StringEnum;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestEnumToBeanType {
 
@@ -25,14 +26,13 @@ public class TestEnumToBeanType {
 
 
     Object approved = stringEnum.toBeanType(Order.Status.APPROVED);
-    Assert.assertTrue(approved == Order.Status.APPROVED);
+    assertEquals(approved, Order.Status.APPROVED);
 
     approved = ordinalEnum.toBeanType(Order.Status.APPROVED);
-    Assert.assertTrue(approved == Order.Status.APPROVED);
+    assertEquals(approved, Order.Status.APPROVED);
 
     Object active = withMapping.toBeanType(Customer.Status.ACTIVE);
-    Assert.assertTrue(active == Customer.Status.ACTIVE);
-
+    assertEquals(active, Customer.Status.ACTIVE);
   }
 
 }
diff --git a/ebean-test/src/test/java/io/ebeaninternal/server/type/TestLocaleParse.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestLocaleParse.java
new file mode 100644
index 000000000..2c7192841
--- /dev/null
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestLocaleParse.java
@@ -0,0 +1,47 @@
+package io.ebeaninternal.server.type;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Locale;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TestLocaleParse {
+
+  @Test
+  public void test() {
+
+    // Examples: "en", "de_DE", "_GB", "en_US_WIN", "de__POSIX", "fr__MAC"
+
+    Locale l = parse("en");
+    assertEquals("en", l.getLanguage());
+
+    l = parse("de_DE");
+    assertEquals("de", l.getLanguage());
+    assertEquals("DE", l.getCountry());
+
+    l = parse("en_US_WIN");
+    assertEquals("en", l.getLanguage());
+    assertEquals("US", l.getCountry());
+    assertEquals("WIN", l.getVariant());
+
+    l = parse("_GB");
+    assertEquals("", l.getLanguage());
+    assertEquals("GB", l.getCountry());
+    assertEquals("", l.getVariant());
+
+    l = parse("fr__MAC");
+    assertEquals("fr", l.getLanguage());
+    assertEquals("", l.getCountry());
+    assertEquals("MAC", l.getVariant());
+
+    l = parse("de__POSIX");
+    assertEquals("de", l.getLanguage());
+    assertEquals("", l.getCountry());
+    assertEquals("POSIX", l.getVariant());
+  }
+
+  private Locale parse(String value) {
+    return new ScalarTypeLocale().parse(value);
+  }
+}
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/TestScalarTypeUUIDBinaryConversion.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestScalarTypeUUIDBinaryConversion.java
similarity index 71%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/TestScalarTypeUUIDBinaryConversion.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/TestScalarTypeUUIDBinaryConversion.java
index d5e5bd109..818502d94 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/TestScalarTypeUUIDBinaryConversion.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestScalarTypeUUIDBinaryConversion.java
@@ -1,34 +1,33 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.UUID;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestScalarTypeUUIDBinaryConversion {
 
   @Test
   public void testConversion() {
-
     UUID id = UUID.randomUUID();
 
     byte[] bytes = ScalarTypeUUIDBinary.convertToBytes(id, false);
-    Assert.assertEquals(16, bytes.length);
+    assertEquals(16, bytes.length);
 
     UUID id2 = ScalarTypeUUIDBinary.convertFromBytes(bytes, false);
-    Assert.assertEquals(id, id2);
+    assertEquals(id, id2);
   }
 
   @Test
   public void testConversionOptimized() {
-
     UUID id = UUID.randomUUID();
 
     byte[] bytes = ScalarTypeUUIDBinary.convertToBytes(id, true);
-    Assert.assertEquals(16, bytes.length);
+    assertEquals(16, bytes.length);
 
     UUID id2 = ScalarTypeUUIDBinary.convertFromBytes(bytes, true);
-    Assert.assertEquals(id, id2);
+    assertEquals(id, id2);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/unitinternal/TestSimpleEncryptor.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestSimpleEncryptor.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/unitinternal/TestSimpleEncryptor.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/TestSimpleEncryptor.java
index 439b68020..7ea6d2b3c 100644
--- a/ebean-core/src/test/java/org/tests/unitinternal/TestSimpleEncryptor.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestSimpleEncryptor.java
@@ -1,16 +1,15 @@
-package org.tests.unitinternal;
+package io.ebeaninternal.server.type;
 
 import io.ebean.BaseTestCase;
 import io.ebean.config.EncryptKey;
-import io.ebeaninternal.server.type.SimpleAesEncryptor;
+import org.junit.jupiter.api.Test;
 import org.tests.basic.encrypt.BasicEncryptKey;
-import org.junit.Assert;
-import org.junit.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
 
 import java.sql.Timestamp;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestSimpleEncryptor extends BaseTestCase {
 
   @Test
@@ -25,7 +24,7 @@ public class TestSimpleEncryptor extends BaseTestCase {
     byte[] ecData = e.encrypt(data, key);
 
     byte[] deData = e.decrypt(ecData, key);
-    
+
     assertThat(data).containsExactly(deData);
 
     Timestamp t = new Timestamp(System.currentTimeMillis());
@@ -33,7 +32,6 @@ public class TestSimpleEncryptor extends BaseTestCase {
 
     String tsFormat = e.decryptString(ecTimestamp, key);
     Timestamp t1 = Timestamp.valueOf(tsFormat);
-    Assert.assertEquals(t, t1);
-
+    assertEquals(t, t1);
   }
 }
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/TestTypeManager.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestTypeManager.java
similarity index 78%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/TestTypeManager.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/TestTypeManager.java
index da942345d..c28da92a7 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/TestTypeManager.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/TestTypeManager.java
@@ -1,18 +1,14 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.BaseTestCase;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebean.core.type.ScalarType;
 import io.ebean.server.type.MyDayOfWeek;
 import io.ebean.server.type.MyEnum;
 import io.ebean.server.type.MySex;
 import io.ebeaninternal.server.core.bootup.BootupClasses;
-import io.ebeaninternal.server.type.DefaultTypeManager;
-import io.ebeaninternal.server.type.RsetDataReader;
-import io.ebeaninternal.server.type.ScalarTypeEnumStandard;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.ivo.Money;
 import org.tests.model.ivo.converter.MoneyTypeConverter;
 
@@ -21,7 +17,9 @@ import java.sql.SQLException;
 import java.sql.Types;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 
 public class TestTypeManager extends BaseTestCase {
 
@@ -51,7 +49,7 @@ public class TestTypeManager extends BaseTestCase {
 
     try {
       typeManager.createEnumScalarType(MyEnum.class, EnumType.STRING);
-      assertTrue("never get here",false);
+      fail("never get here");
     } catch (IllegalStateException e) {
       assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
     }
@@ -81,7 +79,7 @@ public class TestTypeManager extends BaseTestCase {
 
     try {
       typeManager.createEnumScalarType(MyDayOfWeek.class, EnumType.ORDINAL);
-      assertTrue("never get here",false);
+      fail("never get here");
     } catch (IllegalStateException e) {
       assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
     }
@@ -89,52 +87,48 @@ public class TestTypeManager extends BaseTestCase {
 
   @Test
   public void test() {
-
     DefaultTypeManager typeManager = createTypeManager();
 
     ScalarType<?> scalarType = typeManager.getScalarType(Money.class);
-    assertTrue(scalarType.getJdbcType() == Types.DECIMAL);
-    assertTrue(!scalarType.isJdbcNative());
-    Assert.assertEquals(Money.class, scalarType.getType());
-
+    assertEquals(Types.DECIMAL, scalarType.getJdbcType());
+    assertFalse(scalarType.isJdbcNative());
+    assertEquals(Money.class, scalarType.getType());
   }
 
   @Test
   public void testWithConfig() {
     DefaultTypeManager typeManager1 = createTypeManager();
     ScalarType<?> type1 = typeManager1.createEnumScalarType(MySex.class, null);
-    assertThat(type1 instanceof ScalarTypeEnumStandard.OrdinalEnum);
+    assertThat(type1).isInstanceOf(ScalarTypeEnumStandard.OrdinalEnum.class);
     //
     DefaultTypeManager typeManager2 = createTypeManagerDefaultEnumTypeString();
     ScalarType<?> type2 = typeManager2.createEnumScalarType(MySex.class, null);
-    assertThat(type2 instanceof ScalarTypeEnumStandard.StringEnum);
+    assertThat(type2).isInstanceOf(ScalarTypeEnumStandard.StringEnum.class);
     //
     DefaultTypeManager typeManager3 = createTypeManagerDefaultEnumTypeString();
     ScalarType<?> type3 = typeManager3.createEnumScalarType(MySex.class, EnumType.ORDINAL);
-    assertThat(type3 instanceof ScalarTypeEnumStandard.OrdinalEnum);
+    assertThat(type3).isInstanceOf(ScalarTypeEnumStandard.OrdinalEnum.class);
   }
 
   private DefaultTypeManager createTypeManager() {
-
-    ServerConfig serverConfig = new ServerConfig();
-    serverConfig.setDatabasePlatform(new H2Platform());
+    DatabaseConfig config = new DatabaseConfig();
+    config.setDatabasePlatform(new H2Platform());
 
     BootupClasses bootupClasses = new BootupClasses();
     bootupClasses.getAttributeConverters().add(MoneyTypeConverter.class);
 
-    return new DefaultTypeManager(serverConfig, bootupClasses);
+    return new DefaultTypeManager(config, bootupClasses);
   }
 
   private DefaultTypeManager createTypeManagerDefaultEnumTypeString() {
-
-    ServerConfig serverConfig = new ServerConfig();
-    serverConfig.setDatabasePlatform(new H2Platform());
-    serverConfig.setDefaultEnumType(EnumType.STRING);
+    DatabaseConfig config = new DatabaseConfig();
+    config.setDatabasePlatform(new H2Platform());
+    config.setDefaultEnumType(EnumType.STRING);
 
     BootupClasses bootupClasses = new BootupClasses();
     bootupClasses.getAttributeConverters().add(MoneyTypeConverter.class);
 
-    return new DefaultTypeManager(serverConfig, bootupClasses);
+    return new DefaultTypeManager(config, bootupClasses);
   }
 
   /**
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/TypeReflectHelperTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/TypeReflectHelperTest.java
similarity index 99%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/TypeReflectHelperTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/TypeReflectHelperTest.java
index aed4f42ee..20da9cf98 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/TypeReflectHelperTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/TypeReflectHelperTest.java
@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.type;
 
 import io.ebean.config.ScalarTypeConverter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.ivo.Money;
 import org.tests.model.ivo.Oid;
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/type/UtilDateParserTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/type/UtilDateParserTest.java
similarity index 90%
rename from ebean-core/src/test/java/io/ebeaninternal/server/type/UtilDateParserTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/type/UtilDateParserTest.java
index 50131893b..859519881 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/type/UtilDateParserTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/type/UtilDateParserTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.type;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Date;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/util/ArrayStackTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/util/ArrayStackTest.java
similarity index 71%
rename from ebean-core/src/test/java/io/ebeaninternal/server/util/ArrayStackTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/util/ArrayStackTest.java
index 2b9661727..4d54b968e 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/util/ArrayStackTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/util/ArrayStackTest.java
@@ -1,17 +1,17 @@
 package io.ebeaninternal.server.util;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.EmptyStackException;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 
 public class ArrayStackTest {
 
   @Test
-  public void testPushPop() throws Exception {
-
+  public void testPushPop() {
     ArrayStack<String> stack = new ArrayStack<>();
     stack.push("1");
     stack.push("2");
@@ -23,8 +23,7 @@ public class ArrayStackTest {
   }
 
   @Test
-  public void testPushPop_given_stackInitialSizeExceeded() throws Exception {
-
+  public void testPushPop_given_stackInitialSizeExceeded() {
     ArrayStack<String> stack = new ArrayStack<>(2);
     stack.push("1");
     stack.push("2");
@@ -35,34 +34,28 @@ public class ArrayStackTest {
     assertThat(stack.pop()).isEqualTo("1");
   }
 
-  @Test(expected = EmptyStackException.class)
-  public void testPop_given_emptyStack_throws() throws Exception {
-
+  @Test
+  public void testPop_given_emptyStack_throws() {
     ArrayStack<String> stack = new ArrayStack<>();
-    stack.pop();
-  }
-
-  @Test(expected = EmptyStackException.class)
-  public void testPeek_given_empty_throws() throws Exception {
-
-    ArrayStack<String> stack = new ArrayStack<>();
-
-    assertThat(stack.peek());
+    assertThrows(EmptyStackException.class, stack::pop);
   }
 
   @Test
-  public void testPeek_given_notEmpty() throws Exception {
+  public void testPeek_given_empty_throws() {
+    ArrayStack<String> stack = new ArrayStack<>();
+    assertThrows(EmptyStackException.class, stack::peek);
+  }
 
+  @Test
+  public void testPeek_given_notEmpty() {
     ArrayStack<String> stack = new ArrayStack<>();
     stack.push("1");
     assertThat(stack.peek()).isEqualTo("1");
   }
 
   @Test
-  public void testPeekWithNull() throws Exception {
-
+  public void testPeekWithNull() {
     ArrayStack<String> stack = new ArrayStack<>();
-
     assertThat(stack.peekWithNull()).isNull();
 
     stack.push("1");
@@ -70,8 +63,7 @@ public class ArrayStackTest {
   }
 
   @Test
-  public void testIsEmpty() throws Exception {
-
+  public void testIsEmpty() {
     ArrayStack<String> stack = new ArrayStack<>();
     assertThat(stack.isEmpty()).isTrue();
 
@@ -80,8 +72,7 @@ public class ArrayStackTest {
   }
 
   @Test
-  public void testSize() throws Exception {
-
+  public void testSize() {
     ArrayStack<String> stack = new ArrayStack<>();
     assertThat(stack.size()).isEqualTo(0);
 
@@ -92,8 +83,7 @@ public class ArrayStackTest {
   }
 
   @Test
-  public void testContains() throws Exception {
-
+  public void testContains() {
     ArrayStack<String> stack = new ArrayStack<>();
     stack.push("1");
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/util/BindParamsParserTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/util/BindParamsParserTest.java
similarity index 93%
rename from ebean-core/src/test/java/io/ebeaninternal/server/util/BindParamsParserTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/util/BindParamsParserTest.java
index 0b874aa8f..cebfe6784 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/util/BindParamsParserTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/util/BindParamsParserTest.java
@@ -1,11 +1,11 @@
 package io.ebeaninternal.server.util;
 
 import io.ebeaninternal.api.BindParams;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class BindParamsParserTest {
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/util/ChecksumTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/util/ChecksumTest.java
similarity index 94%
rename from ebean-core/src/test/java/io/ebeaninternal/server/util/ChecksumTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/util/ChecksumTest.java
index 9eceabb0a..440712865 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/util/ChecksumTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/util/ChecksumTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.util;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/util/DSelectColumnsParserTest.java b/ebean-test/src/test/java/io/ebeaninternal/server/util/DSelectColumnsParserTest.java
similarity index 97%
rename from ebean-core/src/test/java/io/ebeaninternal/server/util/DSelectColumnsParserTest.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/util/DSelectColumnsParserTest.java
index cc9234925..5e0ebcbbb 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/util/DSelectColumnsParserTest.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/util/DSelectColumnsParserTest.java
@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.util;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Set;
 
diff --git a/ebean-core/src/test/java/io/ebeaninternal/server/util/Md5Test.java b/ebean-test/src/test/java/io/ebeaninternal/server/util/Md5Test.java
similarity index 88%
rename from ebean-core/src/test/java/io/ebeaninternal/server/util/Md5Test.java
rename to ebean-test/src/test/java/io/ebeaninternal/server/util/Md5Test.java
index 9f0106cae..bc1bf8272 100644
--- a/ebean-core/src/test/java/io/ebeaninternal/server/util/Md5Test.java
+++ b/ebean-test/src/test/java/io/ebeaninternal/server/util/Md5Test.java
@@ -1,9 +1,9 @@
 package io.ebeaninternal.server.util;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 
 public class Md5Test {
 
diff --git a/ebean-core/src/test/java/io/ebeanservice/docstore/api/support/DocStoreBeanBaseAdapterTest.java b/ebean-test/src/test/java/io/ebeanservice/docstore/api/support/DocStoreBeanBaseAdapterTest.java
similarity index 90%
rename from ebean-core/src/test/java/io/ebeanservice/docstore/api/support/DocStoreBeanBaseAdapterTest.java
rename to ebean-test/src/test/java/io/ebeanservice/docstore/api/support/DocStoreBeanBaseAdapterTest.java
index bbc8c5752..30708eda0 100644
--- a/ebean-core/src/test/java/io/ebeanservice/docstore/api/support/DocStoreBeanBaseAdapterTest.java
+++ b/ebean-test/src/test/java/io/ebeanservice/docstore/api/support/DocStoreBeanBaseAdapterTest.java
@@ -9,8 +9,8 @@ import io.ebeaninternal.server.core.PersistRequestBean;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.meta.DeployBeanDescriptor;
 import io.ebeanservice.docstore.api.DocStoreUpdateContext;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
-import org.junit.Test;
 
 import java.io.IOException;
 
@@ -25,14 +25,14 @@ public class DocStoreBeanBaseAdapterTest extends BaseTestCase {
   public void test_basic_construction() throws Exception {
 
     SpiEbeanServer server = spiEbeanServer();
-    BeanDescriptor<Order> orderDesc = server.getBeanDescriptor(Order.class);
+    BeanDescriptor<Order> orderDesc = server.descriptor(Order.class);
 
     DeployBeanDescriptor<Order> deployDesc = (DeployBeanDescriptor<Order>) mock(DeployBeanDescriptor.class);
 
     TDAdapter<Order> adapter = new TDAdapter<>(orderDesc, deployDesc);
 
-    assertThat(adapter.getIndexName()).isEqualTo("order");
-    assertThat(adapter.getIndexType()).isEqualTo("order");
+    assertThat(adapter.indexName()).isEqualTo("order");
+    assertThat(adapter.indexType()).isEqualTo("order");
     assertThat(adapter.getQueueId()).isEqualTo("order");
   }
 
diff --git a/ebean-core/src/test/java/io/ebeanservice/docstore/api/support/DocStoreDeleteEventTest.java b/ebean-test/src/test/java/io/ebeanservice/docstore/api/support/DocStoreDeleteEventTest.java
similarity index 84%
rename from ebean-core/src/test/java/io/ebeanservice/docstore/api/support/DocStoreDeleteEventTest.java
rename to ebean-test/src/test/java/io/ebeanservice/docstore/api/support/DocStoreDeleteEventTest.java
index 9381188cf..3c10ee57e 100644
--- a/ebean-core/src/test/java/io/ebeanservice/docstore/api/support/DocStoreDeleteEventTest.java
+++ b/ebean-test/src/test/java/io/ebeanservice/docstore/api/support/DocStoreDeleteEventTest.java
@@ -1,28 +1,26 @@
 package io.ebeanservice.docstore.api.support;
 
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.DocStoreQueueEntry;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
 import io.ebean.plugin.BeanDocType;
 import io.ebean.plugin.BeanType;
 import io.ebeanservice.docstore.api.DocStoreUpdates;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import org.tests.model.basic.Order;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
 
 public class DocStoreDeleteEventTest {
 
-  static EbeanServer server = Ebean.getDefaultServer();
+  static Database server = DB.getDefault();
 
   <T> BeanType<T> beanType(Class<T> cls) {
-    return server.getPluginApi().getBeanType(cls);
+    return server.pluginApi().beanType(cls);
   }
 
   BeanType<Order> orderType() {
diff --git a/ebean-core/src/test/java/io/ebeanservice/docstore/api/support/DocStoreIndexEventTest.java b/ebean-test/src/test/java/io/ebeanservice/docstore/api/support/DocStoreIndexEventTest.java
similarity index 90%
rename from ebean-core/src/test/java/io/ebeanservice/docstore/api/support/DocStoreIndexEventTest.java
rename to ebean-test/src/test/java/io/ebeanservice/docstore/api/support/DocStoreIndexEventTest.java
index c214f22ef..e353f1a01 100644
--- a/ebean-core/src/test/java/io/ebeanservice/docstore/api/support/DocStoreIndexEventTest.java
+++ b/ebean-test/src/test/java/io/ebeanservice/docstore/api/support/DocStoreIndexEventTest.java
@@ -1,14 +1,14 @@
 package io.ebeanservice.docstore.api.support;
 
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.DocStoreQueueEntry;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
 import io.ebean.plugin.BeanDocType;
 import io.ebean.plugin.BeanType;
 import io.ebeanservice.docstore.api.DocStoreUpdates;
-import org.tests.model.basic.Order;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
+import org.tests.model.basic.Order;
 
 import java.util.List;
 
@@ -17,10 +17,10 @@ import static org.mockito.Mockito.*;
 
 public class DocStoreIndexEventTest {
 
-  static EbeanServer server = Ebean.getDefaultServer();
+  static Database server = DB.getDefault();
 
   <T> BeanType<T> beanType(Class<T> cls) {
-    return server.getPluginApi().getBeanType(cls);
+    return server.pluginApi().beanType(cls);
   }
 
   BeanType<Order> orderType() {
diff --git a/ebean-core/src/test/java/main/StartCockroach.java b/ebean-test/src/test/java/main/StartCockroach.java
similarity index 100%
rename from ebean-core/src/test/java/main/StartCockroach.java
rename to ebean-test/src/test/java/main/StartCockroach.java
diff --git a/ebean-core/src/test/java/main/StartMariaDb.java b/ebean-test/src/test/java/main/StartMariaDb.java
similarity index 100%
rename from ebean-core/src/test/java/main/StartMariaDb.java
rename to ebean-test/src/test/java/main/StartMariaDb.java
diff --git a/ebean-core/src/test/java/main/StartMySql.java b/ebean-test/src/test/java/main/StartMySql.java
similarity index 100%
rename from ebean-core/src/test/java/main/StartMySql.java
rename to ebean-test/src/test/java/main/StartMySql.java
diff --git a/ebean-core/src/test/java/main/StartNuoDB.java b/ebean-test/src/test/java/main/StartNuoDB.java
similarity index 100%
rename from ebean-core/src/test/java/main/StartNuoDB.java
rename to ebean-test/src/test/java/main/StartNuoDB.java
diff --git a/ebean-core/src/test/java/main/StartOracle.java b/ebean-test/src/test/java/main/StartOracle.java
similarity index 100%
rename from ebean-core/src/test/java/main/StartOracle.java
rename to ebean-test/src/test/java/main/StartOracle.java
diff --git a/ebean-core/src/test/java/main/StartPostgres.java b/ebean-test/src/test/java/main/StartPostgres.java
similarity index 100%
rename from ebean-core/src/test/java/main/StartPostgres.java
rename to ebean-test/src/test/java/main/StartPostgres.java
diff --git a/ebean-core/src/test/java/main/StartSqlServer.java b/ebean-test/src/test/java/main/StartSqlServer.java
similarity index 100%
rename from ebean-core/src/test/java/main/StartSqlServer.java
rename to ebean-test/src/test/java/main/StartSqlServer.java
diff --git a/ebean-core/src/test/java/misc/migration/history/v1_0/EHistory7.java b/ebean-test/src/test/java/misc/migration/history/v1_0/EHistory7.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/history/v1_0/EHistory7.java
rename to ebean-test/src/test/java/misc/migration/history/v1_0/EHistory7.java
index 28ca8c5de..0148551a6 100644
--- a/ebean-core/src/test/java/misc/migration/history/v1_0/EHistory7.java
+++ b/ebean-test/src/test/java/misc/migration/history/v1_0/EHistory7.java
@@ -1,12 +1,12 @@
 package misc.migration.history.v1_0;
 
 
+import io.ebean.annotation.History;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-
 /**
  * detects a bug where dropHistoryTable is not applied correctly
  *
diff --git a/ebean-core/src/test/java/misc/migration/history/v1_1/EHistory7.java b/ebean-test/src/test/java/misc/migration/history/v1_1/EHistory7.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/history/v1_1/EHistory7.java
rename to ebean-test/src/test/java/misc/migration/history/v1_1/EHistory7.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/CKeyAssoc.java b/ebean-test/src/test/java/misc/migration/v1_0/CKeyAssoc.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/CKeyAssoc.java
rename to ebean-test/src/test/java/misc/migration/v1_0/CKeyAssoc.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/CKeyDetail.java b/ebean-test/src/test/java/misc/migration/v1_0/CKeyDetail.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/CKeyDetail.java
rename to ebean-test/src/test/java/misc/migration/v1_0/CKeyDetail.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/CKeyParent.java b/ebean-test/src/test/java/misc/migration/v1_0/CKeyParent.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/CKeyParent.java
rename to ebean-test/src/test/java/misc/migration/v1_0/CKeyParent.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/CKeyParentId.java b/ebean-test/src/test/java/misc/migration/v1_0/CKeyParentId.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/CKeyParentId.java
rename to ebean-test/src/test/java/misc/migration/v1_0/CKeyParentId.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/DfkCascade.java b/ebean-test/src/test/java/misc/migration/v1_0/DfkCascade.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/DfkCascade.java
rename to ebean-test/src/test/java/misc/migration/v1_0/DfkCascade.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/DfkCascadeOne.java b/ebean-test/src/test/java/misc/migration/v1_0/DfkCascadeOne.java
similarity index 58%
rename from ebean-core/src/test/java/misc/migration/v1_0/DfkCascadeOne.java
rename to ebean-test/src/test/java/misc/migration/v1_0/DfkCascadeOne.java
index 1d57570bf..b05ccab94 100644
--- a/ebean-core/src/test/java/misc/migration/v1_0/DfkCascadeOne.java
+++ b/ebean-test/src/test/java/misc/migration/v1_0/DfkCascadeOne.java
@@ -1,11 +1,6 @@
 package misc.migration.v1_0;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/DfkNone.java b/ebean-test/src/test/java/misc/migration/v1_0/DfkNone.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/DfkNone.java
rename to ebean-test/src/test/java/misc/migration/v1_0/DfkNone.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/DfkNoneViaJoin.java b/ebean-test/src/test/java/misc/migration/v1_0/DfkNoneViaJoin.java
similarity index 50%
rename from ebean-core/src/test/java/misc/migration/v1_0/DfkNoneViaJoin.java
rename to ebean-test/src/test/java/misc/migration/v1_0/DfkNoneViaJoin.java
index c8147fdcd..96e588017 100644
--- a/ebean-core/src/test/java/misc/migration/v1_0/DfkNoneViaJoin.java
+++ b/ebean-test/src/test/java/misc/migration/v1_0/DfkNoneViaJoin.java
@@ -1,12 +1,6 @@
 package misc.migration.v1_0;
 
-import javax.persistence.ConstraintMode;
-import javax.persistence.Entity;
-import javax.persistence.ForeignKey;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "migtest_fk_none_via_join")
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/DfkOne.java b/ebean-test/src/test/java/misc/migration/v1_0/DfkOne.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/DfkOne.java
rename to ebean-test/src/test/java/misc/migration/v1_0/DfkOne.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/DfkSetNull.java b/ebean-test/src/test/java/misc/migration/v1_0/DfkSetNull.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/DfkSetNull.java
rename to ebean-test/src/test/java/misc/migration/v1_0/DfkSetNull.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/EBasic.java b/ebean-test/src/test/java/misc/migration/v1_0/EBasic.java
similarity index 99%
rename from ebean-core/src/test/java/misc/migration/v1_0/EBasic.java
rename to ebean-test/src/test/java/misc/migration/v1_0/EBasic.java
index e1c16afd6..6e895a2f1 100644
--- a/ebean-core/src/test/java/misc/migration/v1_0/EBasic.java
+++ b/ebean-test/src/test/java/misc/migration/v1_0/EBasic.java
@@ -10,7 +10,6 @@ import javax.persistence.Id;
 import javax.persistence.ManyToOne;
 import javax.persistence.Table;
 import javax.validation.constraints.Size;
-
 import java.sql.Timestamp;
 
 @Entity
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/EEnum.java b/ebean-test/src/test/java/misc/migration/v1_0/EEnum.java
similarity index 97%
rename from ebean-core/src/test/java/misc/migration/v1_0/EEnum.java
rename to ebean-test/src/test/java/misc/migration/v1_0/EEnum.java
index f2db733e7..834099a10 100644
--- a/ebean-core/src/test/java/misc/migration/v1_0/EEnum.java
+++ b/ebean-test/src/test/java/misc/migration/v1_0/EEnum.java
@@ -1,16 +1,16 @@
 package misc.migration.v1_0;
 
 
+import io.ebean.annotation.EnumValue;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.EnumValue;
-
 @Entity
 @Table(name = "migtest_e_enum")
 public class EEnum {
-  
+
   public enum Status {
     @EnumValue("N")
     NEW,
@@ -21,9 +21,9 @@ public class EEnum {
     @EnumValue("I")
     INACTIVE,
   }
-  
+
   @Id
   Integer id;
-  
+
   Status testStatus;
 }
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/EHistory.java b/ebean-test/src/test/java/misc/migration/v1_0/EHistory.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/EHistory.java
rename to ebean-test/src/test/java/misc/migration/v1_0/EHistory.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/EHistory2.java b/ebean-test/src/test/java/misc/migration/v1_0/EHistory2.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/EHistory2.java
rename to ebean-test/src/test/java/misc/migration/v1_0/EHistory2.java
index d8c76df75..d29a2c45b 100644
--- a/ebean-core/src/test/java/misc/migration/v1_0/EHistory2.java
+++ b/ebean-test/src/test/java/misc/migration/v1_0/EHistory2.java
@@ -1,13 +1,13 @@
 package misc.migration.v1_0;
 
 
+import io.ebean.annotation.History;
+import io.ebean.annotation.HistoryExclude;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-import io.ebean.annotation.HistoryExclude;
-
 @Entity
 @Table(name = "migtest_e_history2")
 @History
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/EHistory3.java b/ebean-test/src/test/java/misc/migration/v1_0/EHistory3.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/EHistory3.java
rename to ebean-test/src/test/java/misc/migration/v1_0/EHistory3.java
index b5e41db5d..1224581a7 100644
--- a/ebean-core/src/test/java/misc/migration/v1_0/EHistory3.java
+++ b/ebean-test/src/test/java/misc/migration/v1_0/EHistory3.java
@@ -1,12 +1,12 @@
 package misc.migration.v1_0;
 
 
+import io.ebean.annotation.History;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-
 
 @Entity
 @Table(name = "migtest_e_history3")
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/EHistory4.java b/ebean-test/src/test/java/misc/migration/v1_0/EHistory4.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/EHistory4.java
rename to ebean-test/src/test/java/misc/migration/v1_0/EHistory4.java
index aba167995..ce1b464e1 100644
--- a/ebean-core/src/test/java/misc/migration/v1_0/EHistory4.java
+++ b/ebean-test/src/test/java/misc/migration/v1_0/EHistory4.java
@@ -1,12 +1,12 @@
 package misc.migration.v1_0;
 
 
+import io.ebean.annotation.History;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-
 
 @Entity
 @Table(name = "migtest_e_history4")
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/EHistory5.java b/ebean-test/src/test/java/misc/migration/v1_0/EHistory5.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/EHistory5.java
rename to ebean-test/src/test/java/misc/migration/v1_0/EHistory5.java
index 133a00c3d..a6e5f5ee6 100644
--- a/ebean-core/src/test/java/misc/migration/v1_0/EHistory5.java
+++ b/ebean-test/src/test/java/misc/migration/v1_0/EHistory5.java
@@ -1,12 +1,12 @@
 package misc.migration.v1_0;
 
 
+import io.ebean.annotation.History;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-
 
 @Entity
 @Table(name = "migtest_e_history5")
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/EHistory6.java b/ebean-test/src/test/java/misc/migration/v1_0/EHistory6.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/EHistory6.java
rename to ebean-test/src/test/java/misc/migration/v1_0/EHistory6.java
index c95eb7796..9a1fd23b7 100644
--- a/ebean-core/src/test/java/misc/migration/v1_0/EHistory6.java
+++ b/ebean-test/src/test/java/misc/migration/v1_0/EHistory6.java
@@ -1,13 +1,13 @@
 package misc.migration.v1_0;
 
 
+import io.ebean.annotation.History;
+import io.ebean.annotation.NotNull;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-import io.ebean.annotation.NotNull;
-
 
 @Entity
 @Table(name = "migtest_e_history6")
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/ERef.java b/ebean-test/src/test/java/misc/migration/v1_0/ERef.java
similarity index 98%
rename from ebean-core/src/test/java/misc/migration/v1_0/ERef.java
rename to ebean-test/src/test/java/misc/migration/v1_0/ERef.java
index f4cfdf875..46103c173 100644
--- a/ebean-core/src/test/java/misc/migration/v1_0/ERef.java
+++ b/ebean-test/src/test/java/misc/migration/v1_0/ERef.java
@@ -1,23 +1,22 @@
 package misc.migration.v1_0;
 
-import java.util.List;
+import io.ebean.annotation.Index;
+import io.ebean.annotation.NotNull;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.OneToMany;
 import javax.persistence.Table;
 import javax.validation.constraints.Size;
-
-import io.ebean.annotation.Index;
-import io.ebean.annotation.NotNull;
+import java.util.List;
 
 @Entity
 @Table(name = "migtest_e_ref")
 public class ERef {
-  
+
   @Id
   Integer id;
-  
+
   @OneToMany
   List<EBasic> basics;
 
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/ESoftdelete.java b/ebean-test/src/test/java/misc/migration/v1_0/ESoftdelete.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/ESoftdelete.java
rename to ebean-test/src/test/java/misc/migration/v1_0/ESoftdelete.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/MtmChild.java b/ebean-test/src/test/java/misc/migration/v1_0/MtmChild.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/MtmChild.java
rename to ebean-test/src/test/java/misc/migration/v1_0/MtmChild.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/MtmMaster.java b/ebean-test/src/test/java/misc/migration/v1_0/MtmMaster.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/MtmMaster.java
rename to ebean-test/src/test/java/misc/migration/v1_0/MtmMaster.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/OtoChild.java b/ebean-test/src/test/java/misc/migration/v1_0/OtoChild.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/OtoChild.java
rename to ebean-test/src/test/java/misc/migration/v1_0/OtoChild.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_0/OtoMaster.java b/ebean-test/src/test/java/misc/migration/v1_0/OtoMaster.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_0/OtoMaster.java
rename to ebean-test/src/test/java/misc/migration/v1_0/OtoMaster.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/CKeyAssoc.java b/ebean-test/src/test/java/misc/migration/v1_1/CKeyAssoc.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/CKeyAssoc.java
rename to ebean-test/src/test/java/misc/migration/v1_1/CKeyAssoc.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/CKeyDetail.java b/ebean-test/src/test/java/misc/migration/v1_1/CKeyDetail.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/CKeyDetail.java
rename to ebean-test/src/test/java/misc/migration/v1_1/CKeyDetail.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/CKeyParent.java b/ebean-test/src/test/java/misc/migration/v1_1/CKeyParent.java
similarity index 82%
rename from ebean-core/src/test/java/misc/migration/v1_1/CKeyParent.java
rename to ebean-test/src/test/java/misc/migration/v1_1/CKeyParent.java
index e331399ed..5c039bb06 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/CKeyParent.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/CKeyParent.java
@@ -1,12 +1,6 @@
 package misc.migration.v1_1;
 
-import javax.persistence.CascadeType;
-import javax.persistence.EmbeddedId;
-import javax.persistence.Entity;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/CKeyParentId.java b/ebean-test/src/test/java/misc/migration/v1_1/CKeyParentId.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/CKeyParentId.java
rename to ebean-test/src/test/java/misc/migration/v1_1/CKeyParentId.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/DfkCascade.java b/ebean-test/src/test/java/misc/migration/v1_1/DfkCascade.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/DfkCascade.java
rename to ebean-test/src/test/java/misc/migration/v1_1/DfkCascade.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/DfkCascadeOne.java b/ebean-test/src/test/java/misc/migration/v1_1/DfkCascadeOne.java
similarity index 58%
rename from ebean-core/src/test/java/misc/migration/v1_1/DfkCascadeOne.java
rename to ebean-test/src/test/java/misc/migration/v1_1/DfkCascadeOne.java
index 07a523039..deed36868 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/DfkCascadeOne.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/DfkCascadeOne.java
@@ -1,11 +1,6 @@
 package misc.migration.v1_1;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/DfkNone.java b/ebean-test/src/test/java/misc/migration/v1_1/DfkNone.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/DfkNone.java
rename to ebean-test/src/test/java/misc/migration/v1_1/DfkNone.java
diff --git a/ebean-test/src/test/java/misc/migration/v1_1/DfkNoneViaJoin.java b/ebean-test/src/test/java/misc/migration/v1_1/DfkNoneViaJoin.java
new file mode 100644
index 000000000..5cac1da05
--- /dev/null
+++ b/ebean-test/src/test/java/misc/migration/v1_1/DfkNoneViaJoin.java
@@ -0,0 +1,16 @@
+package misc.migration.v1_1;
+
+import javax.persistence.*;
+
+@Entity
+@Table(name = "migtest_fk_none_via_join")
+public class DfkNoneViaJoin {
+
+  @Id
+  long id;
+
+  @ManyToOne
+  @JoinColumn(name = "one_id", foreignKey = @ForeignKey(ConstraintMode.CONSTRAINT))
+  DfkOne one;
+
+}
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/DfkOne.java b/ebean-test/src/test/java/misc/migration/v1_1/DfkOne.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/DfkOne.java
rename to ebean-test/src/test/java/misc/migration/v1_1/DfkOne.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/DfkSetNull.java b/ebean-test/src/test/java/misc/migration/v1_1/DfkSetNull.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/DfkSetNull.java
rename to ebean-test/src/test/java/misc/migration/v1_1/DfkSetNull.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/EBasic.java b/ebean-test/src/test/java/misc/migration/v1_1/EBasic.java
similarity index 90%
rename from ebean-core/src/test/java/misc/migration/v1_1/EBasic.java
rename to ebean-test/src/test/java/misc/migration/v1_1/EBasic.java
index 9e5b1742d..0c2e5cde1 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/EBasic.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/EBasic.java
@@ -1,18 +1,10 @@
 package misc.migration.v1_1;
 
-import io.ebean.annotation.DbDefault;
-import io.ebean.annotation.DbMigration;
-import io.ebean.annotation.EnumValue;
 import io.ebean.annotation.Index;
-import io.ebean.annotation.NotNull;
+import io.ebean.annotation.*;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
-
 import java.sql.Timestamp;
 
 @Entity
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/EEnum.java b/ebean-test/src/test/java/misc/migration/v1_1/EEnum.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/EEnum.java
rename to ebean-test/src/test/java/misc/migration/v1_1/EEnum.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/EHistory.java b/ebean-test/src/test/java/misc/migration/v1_1/EHistory.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/EHistory.java
rename to ebean-test/src/test/java/misc/migration/v1_1/EHistory.java
index 9cad6715c..d949d4838 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/EHistory.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/EHistory.java
@@ -1,15 +1,15 @@
 package misc.migration.v1_1;
 
 
+import io.ebean.annotation.DbComment;
+import io.ebean.annotation.DbMigration;
+import io.ebean.annotation.History;
+import io.ebean.annotation.Platform;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.Platform;
-import io.ebean.annotation.DbComment;
-import io.ebean.annotation.DbMigration;
-import io.ebean.annotation.History;
-
 @Entity
 @Table(name = "migtest_e_history")
 @History
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/EHistory2.java b/ebean-test/src/test/java/misc/migration/v1_1/EHistory2.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/EHistory2.java
rename to ebean-test/src/test/java/misc/migration/v1_1/EHistory2.java
index 7b05d9fe7..951173c5c 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/EHistory2.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/EHistory2.java
@@ -1,16 +1,16 @@
 package misc.migration.v1_1;
 
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Table;
-import javax.validation.constraints.Size;
-
 import io.ebean.annotation.DbDefault;
 import io.ebean.annotation.History;
 import io.ebean.annotation.HistoryExclude;
 import io.ebean.annotation.NotNull;
 
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.validation.constraints.Size;
+
 @Entity
 @Table(name = "migtest_e_history2")
 @History
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/EHistory3.java b/ebean-test/src/test/java/misc/migration/v1_1/EHistory3.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/EHistory3.java
rename to ebean-test/src/test/java/misc/migration/v1_1/EHistory3.java
index a3756572a..e8ab4ecc8 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/EHistory3.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/EHistory3.java
@@ -1,13 +1,13 @@
 package misc.migration.v1_1;
 
 
+import io.ebean.annotation.History;
+import io.ebean.annotation.HistoryExclude;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-import io.ebean.annotation.HistoryExclude;
-
 
 @Entity
 @Table(name = "migtest_e_history3")
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/EHistory4.java b/ebean-test/src/test/java/misc/migration/v1_1/EHistory4.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/EHistory4.java
rename to ebean-test/src/test/java/misc/migration/v1_1/EHistory4.java
index ba5628390..1ac4d4508 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/EHistory4.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/EHistory4.java
@@ -1,12 +1,12 @@
 package misc.migration.v1_1;
 
 
+import io.ebean.annotation.History;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-
 
 @Entity
 @Table(name = "migtest_e_history4")
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/EHistory5.java b/ebean-test/src/test/java/misc/migration/v1_1/EHistory5.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/EHistory5.java
rename to ebean-test/src/test/java/misc/migration/v1_1/EHistory5.java
index 9bb9aba0b..f10731489 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/EHistory5.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/EHistory5.java
@@ -1,14 +1,14 @@
 package misc.migration.v1_1;
 
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Table;
-
 import io.ebean.annotation.DbDefault;
 import io.ebean.annotation.History;
 import io.ebean.annotation.NotNull;
 
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
 
 @Entity
 @Table(name = "migtest_e_history5")
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/EHistory6.java b/ebean-test/src/test/java/misc/migration/v1_1/EHistory6.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/EHistory6.java
rename to ebean-test/src/test/java/misc/migration/v1_1/EHistory6.java
index c05f51a15..171772b0d 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/EHistory6.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/EHistory6.java
@@ -1,14 +1,14 @@
 package misc.migration.v1_1;
 
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Table;
-
 import io.ebean.annotation.DbDefault;
 import io.ebean.annotation.History;
 import io.ebean.annotation.NotNull;
 
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
 
 @Entity
 @Table(name = "migtest_e_history6")
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/ESoftdelete.java b/ebean-test/src/test/java/misc/migration/v1_1/ESoftdelete.java
similarity index 96%
rename from ebean-core/src/test/java/misc/migration/v1_1/ESoftdelete.java
rename to ebean-test/src/test/java/misc/migration/v1_1/ESoftdelete.java
index 3213ddcd3..7c23cc540 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/ESoftdelete.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/ESoftdelete.java
@@ -1,22 +1,22 @@
 package misc.migration.v1_1;
 
 
+import io.ebean.annotation.SoftDelete;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.SoftDelete;
-
 @Entity
 @Table(name = "migtest_e_softdelete")
 public class ESoftdelete {
-  
+
   @Id
   Integer id;
-  
-  
+
+
   String testString;
-  
+
   @SoftDelete
   boolean deleted;
 }
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/EUser.java b/ebean-test/src/test/java/misc/migration/v1_1/EUser.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/EUser.java
rename to ebean-test/src/test/java/misc/migration/v1_1/EUser.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/MtmChild.java b/ebean-test/src/test/java/misc/migration/v1_1/MtmChild.java
similarity index 99%
rename from ebean-core/src/test/java/misc/migration/v1_1/MtmChild.java
rename to ebean-test/src/test/java/misc/migration/v1_1/MtmChild.java
index 7cf239f91..bdcd43845 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/MtmChild.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/MtmChild.java
@@ -1,11 +1,10 @@
 package misc.migration.v1_1;
 
-import java.util.List;
-
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.ManyToMany;
 import javax.persistence.Table;
+import java.util.List;
 
 @Entity
 @Table(name = "migtest_mtm_c")
@@ -38,7 +37,7 @@ public class MtmChild {
   public List<MtmMaster> getMasters() {
     return masters;
   }
-  
+
   public void setMasters(List<MtmMaster> masters) {
     this.masters = masters;
   }
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/MtmMaster.java b/ebean-test/src/test/java/misc/migration/v1_1/MtmMaster.java
similarity index 99%
rename from ebean-core/src/test/java/misc/migration/v1_1/MtmMaster.java
rename to ebean-test/src/test/java/misc/migration/v1_1/MtmMaster.java
index 067d396dc..ecc97bbe7 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/MtmMaster.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/MtmMaster.java
@@ -1,11 +1,10 @@
 package misc.migration.v1_1;
 
-import java.util.List;
-
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.ManyToMany;
 import javax.persistence.Table;
+import java.util.List;
 
 @Entity
 @Table(name = "migtest_mtm_m")
@@ -38,7 +37,7 @@ public class MtmMaster {
   public List<MtmChild> getChildren() {
     return children;
   }
-  
+
   public void setChildren(List<MtmChild> children) {
     this.children = children;
   }
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/OtoChild.java b/ebean-test/src/test/java/misc/migration/v1_1/OtoChild.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_1/OtoChild.java
rename to ebean-test/src/test/java/misc/migration/v1_1/OtoChild.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_1/OtoMaster.java b/ebean-test/src/test/java/misc/migration/v1_1/OtoMaster.java
similarity index 76%
rename from ebean-core/src/test/java/misc/migration/v1_1/OtoMaster.java
rename to ebean-test/src/test/java/misc/migration/v1_1/OtoMaster.java
index f44bbaa9d..80de9b999 100644
--- a/ebean-core/src/test/java/misc/migration/v1_1/OtoMaster.java
+++ b/ebean-test/src/test/java/misc/migration/v1_1/OtoMaster.java
@@ -1,10 +1,6 @@
 package misc.migration.v1_1;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "migtest_oto_master")
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/CKeyAssoc.java b/ebean-test/src/test/java/misc/migration/v1_2/CKeyAssoc.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/CKeyAssoc.java
rename to ebean-test/src/test/java/misc/migration/v1_2/CKeyAssoc.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/CKeyDetail.java b/ebean-test/src/test/java/misc/migration/v1_2/CKeyDetail.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/CKeyDetail.java
rename to ebean-test/src/test/java/misc/migration/v1_2/CKeyDetail.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/CKeyParent.java b/ebean-test/src/test/java/misc/migration/v1_2/CKeyParent.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/CKeyParent.java
rename to ebean-test/src/test/java/misc/migration/v1_2/CKeyParent.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/CKeyParentId.java b/ebean-test/src/test/java/misc/migration/v1_2/CKeyParentId.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/CKeyParentId.java
rename to ebean-test/src/test/java/misc/migration/v1_2/CKeyParentId.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/DfkCascade.java b/ebean-test/src/test/java/misc/migration/v1_2/DfkCascade.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/DfkCascade.java
rename to ebean-test/src/test/java/misc/migration/v1_2/DfkCascade.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/DfkCascadeOne.java b/ebean-test/src/test/java/misc/migration/v1_2/DfkCascadeOne.java
similarity index 58%
rename from ebean-core/src/test/java/misc/migration/v1_2/DfkCascadeOne.java
rename to ebean-test/src/test/java/misc/migration/v1_2/DfkCascadeOne.java
index 8cdb2a38a..de1e43003 100644
--- a/ebean-core/src/test/java/misc/migration/v1_2/DfkCascadeOne.java
+++ b/ebean-test/src/test/java/misc/migration/v1_2/DfkCascadeOne.java
@@ -1,11 +1,6 @@
 package misc.migration.v1_2;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/DfkNone.java b/ebean-test/src/test/java/misc/migration/v1_2/DfkNone.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/DfkNone.java
rename to ebean-test/src/test/java/misc/migration/v1_2/DfkNone.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/DfkNoneViaJoin.java b/ebean-test/src/test/java/misc/migration/v1_2/DfkNoneViaJoin.java
similarity index 50%
rename from ebean-core/src/test/java/misc/migration/v1_2/DfkNoneViaJoin.java
rename to ebean-test/src/test/java/misc/migration/v1_2/DfkNoneViaJoin.java
index 809b17f76..38b64fee7 100644
--- a/ebean-core/src/test/java/misc/migration/v1_2/DfkNoneViaJoin.java
+++ b/ebean-test/src/test/java/misc/migration/v1_2/DfkNoneViaJoin.java
@@ -1,12 +1,6 @@
 package misc.migration.v1_2;
 
-import javax.persistence.ConstraintMode;
-import javax.persistence.Entity;
-import javax.persistence.ForeignKey;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "migtest_fk_none_via_join")
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/DfkOne.java b/ebean-test/src/test/java/misc/migration/v1_2/DfkOne.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/DfkOne.java
rename to ebean-test/src/test/java/misc/migration/v1_2/DfkOne.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/DfkSetNull.java b/ebean-test/src/test/java/misc/migration/v1_2/DfkSetNull.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/DfkSetNull.java
rename to ebean-test/src/test/java/misc/migration/v1_2/DfkSetNull.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/EBasic.java b/ebean-test/src/test/java/misc/migration/v1_2/EBasic.java
similarity index 99%
rename from ebean-core/src/test/java/misc/migration/v1_2/EBasic.java
rename to ebean-test/src/test/java/misc/migration/v1_2/EBasic.java
index eb2a16d9e..8ebd0776a 100644
--- a/ebean-core/src/test/java/misc/migration/v1_2/EBasic.java
+++ b/ebean-test/src/test/java/misc/migration/v1_2/EBasic.java
@@ -10,7 +10,6 @@ import javax.persistence.Id;
 import javax.persistence.ManyToOne;
 import javax.persistence.Table;
 import javax.validation.constraints.Size;
-
 import java.sql.Timestamp;
 
 @Entity
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/EEnum.java b/ebean-test/src/test/java/misc/migration/v1_2/EEnum.java
similarity index 97%
rename from ebean-core/src/test/java/misc/migration/v1_2/EEnum.java
rename to ebean-test/src/test/java/misc/migration/v1_2/EEnum.java
index 26f2a5d31..b77161f21 100644
--- a/ebean-core/src/test/java/misc/migration/v1_2/EEnum.java
+++ b/ebean-test/src/test/java/misc/migration/v1_2/EEnum.java
@@ -1,16 +1,16 @@
 package misc.migration.v1_2;
 
 
+import io.ebean.annotation.EnumValue;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.EnumValue;
-
 @Entity
 @Table(name = "migtest_e_enum")
 public class EEnum {
-  
+
   public enum Status {
     @EnumValue("N")
     NEW,
@@ -21,9 +21,9 @@ public class EEnum {
     @EnumValue("I")
     INACTIVE,
   }
-  
+
   @Id
   Integer id;
-  
+
   Status testStatus;
 }
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/EHistory.java b/ebean-test/src/test/java/misc/migration/v1_2/EHistory.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/EHistory.java
rename to ebean-test/src/test/java/misc/migration/v1_2/EHistory.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/EHistory2.java b/ebean-test/src/test/java/misc/migration/v1_2/EHistory2.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/EHistory2.java
rename to ebean-test/src/test/java/misc/migration/v1_2/EHistory2.java
index 18a2c17fe..2647b7af4 100644
--- a/ebean-core/src/test/java/misc/migration/v1_2/EHistory2.java
+++ b/ebean-test/src/test/java/misc/migration/v1_2/EHistory2.java
@@ -1,13 +1,13 @@
 package misc.migration.v1_2;
 
 
+import io.ebean.annotation.History;
+import io.ebean.annotation.HistoryExclude;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-import io.ebean.annotation.HistoryExclude;
-
 @Entity
 @Table(name = "migtest_e_history2")
 @History
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/EHistory3.java b/ebean-test/src/test/java/misc/migration/v1_2/EHistory3.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/EHistory3.java
rename to ebean-test/src/test/java/misc/migration/v1_2/EHistory3.java
index f945e6e7b..2e31ad85c 100644
--- a/ebean-core/src/test/java/misc/migration/v1_2/EHistory3.java
+++ b/ebean-test/src/test/java/misc/migration/v1_2/EHistory3.java
@@ -1,12 +1,12 @@
 package misc.migration.v1_2;
 
 
+import io.ebean.annotation.History;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-
 
 @Entity
 @Table(name = "migtest_e_history3")
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/EHistory4.java b/ebean-test/src/test/java/misc/migration/v1_2/EHistory4.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/EHistory4.java
rename to ebean-test/src/test/java/misc/migration/v1_2/EHistory4.java
index 083928e5c..c556f2c47 100644
--- a/ebean-core/src/test/java/misc/migration/v1_2/EHistory4.java
+++ b/ebean-test/src/test/java/misc/migration/v1_2/EHistory4.java
@@ -1,12 +1,12 @@
 package misc.migration.v1_2;
 
 
+import io.ebean.annotation.History;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-
 
 @Entity
 @Table(name = "migtest_e_history4")
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/EHistory5.java b/ebean-test/src/test/java/misc/migration/v1_2/EHistory5.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/EHistory5.java
rename to ebean-test/src/test/java/misc/migration/v1_2/EHistory5.java
index 9de9206a0..957ba43f4 100644
--- a/ebean-core/src/test/java/misc/migration/v1_2/EHistory5.java
+++ b/ebean-test/src/test/java/misc/migration/v1_2/EHistory5.java
@@ -1,12 +1,12 @@
 package misc.migration.v1_2;
 
 
+import io.ebean.annotation.History;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 
-import io.ebean.annotation.History;
-
 
 @Entity
 @Table(name = "migtest_e_history5")
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/EHistory6.java b/ebean-test/src/test/java/misc/migration/v1_2/EHistory6.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/EHistory6.java
rename to ebean-test/src/test/java/misc/migration/v1_2/EHistory6.java
index 1d886ccb2..7c321b580 100644
--- a/ebean-core/src/test/java/misc/migration/v1_2/EHistory6.java
+++ b/ebean-test/src/test/java/misc/migration/v1_2/EHistory6.java
@@ -1,14 +1,14 @@
 package misc.migration.v1_2;
 
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Table;
-
 import io.ebean.annotation.DbDefault;
 import io.ebean.annotation.History;
 import io.ebean.annotation.NotNull;
 
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
 
 @Entity
 @Table(name = "migtest_e_history6")
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/ERef.java b/ebean-test/src/test/java/misc/migration/v1_2/ERef.java
similarity index 98%
rename from ebean-core/src/test/java/misc/migration/v1_2/ERef.java
rename to ebean-test/src/test/java/misc/migration/v1_2/ERef.java
index df16ba21c..66ef3e373 100644
--- a/ebean-core/src/test/java/misc/migration/v1_2/ERef.java
+++ b/ebean-test/src/test/java/misc/migration/v1_2/ERef.java
@@ -1,23 +1,22 @@
 package misc.migration.v1_2;
 
-import java.util.List;
+import io.ebean.annotation.Index;
+import io.ebean.annotation.NotNull;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.OneToMany;
 import javax.persistence.Table;
 import javax.validation.constraints.Size;
-
-import io.ebean.annotation.Index;
-import io.ebean.annotation.NotNull;
+import java.util.List;
 
 @Entity
 @Table(name = "migtest_e_ref")
 public class ERef {
-  
+
   @Id
   Integer id;
-  
+
   @OneToMany
   List<EBasic> basics;
 
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/ESoftdelete.java b/ebean-test/src/test/java/misc/migration/v1_2/ESoftdelete.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/ESoftdelete.java
rename to ebean-test/src/test/java/misc/migration/v1_2/ESoftdelete.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/MtmChild.java b/ebean-test/src/test/java/misc/migration/v1_2/MtmChild.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/MtmChild.java
rename to ebean-test/src/test/java/misc/migration/v1_2/MtmChild.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/MtmMaster.java b/ebean-test/src/test/java/misc/migration/v1_2/MtmMaster.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/MtmMaster.java
rename to ebean-test/src/test/java/misc/migration/v1_2/MtmMaster.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/OtoChild.java b/ebean-test/src/test/java/misc/migration/v1_2/OtoChild.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/OtoChild.java
rename to ebean-test/src/test/java/misc/migration/v1_2/OtoChild.java
diff --git a/ebean-core/src/test/java/misc/migration/v1_2/OtoMaster.java b/ebean-test/src/test/java/misc/migration/v1_2/OtoMaster.java
similarity index 100%
rename from ebean-core/src/test/java/misc/migration/v1_2/OtoMaster.java
rename to ebean-test/src/test/java/misc/migration/v1_2/OtoMaster.java
diff --git a/ebean-test/src/test/java/org/test/BSimpleWithGen.java b/ebean-test/src/test/java/org/etest/BSimpleFor.java
similarity index 88%
rename from ebean-test/src/test/java/org/test/BSimpleWithGen.java
rename to ebean-test/src/test/java/org/etest/BSimpleFor.java
index 5ee189229..2da204412 100644
--- a/ebean-test/src/test/java/org/test/BSimpleWithGen.java
+++ b/ebean-test/src/test/java/org/etest/BSimpleFor.java
@@ -1,4 +1,4 @@
-package org.test;
+package org.etest;
 
 import io.ebean.annotation.WhenModified;
 
@@ -11,7 +11,7 @@ import java.util.List;
 import java.util.Map;
 
 @Entity
-public class BSimpleWithGen {
+public class BSimpleFor {
 
   @Id
   private Integer id;
@@ -29,11 +29,11 @@ public class BSimpleWithGen {
   @Version
   private long version;
 
-  public BSimpleWithGen(String name) {
+  public BSimpleFor(String name) {
     this.name = name;
   }
 
-  public BSimpleWithGen(String name, String other) {
+  public BSimpleFor(String name, String other) {
     this.name = name;
     this.other = other;
   }
diff --git a/ebean-test/src/test/java/org/test/ForTestsBeforeAfterTest.java b/ebean-test/src/test/java/org/etest/ForTestsBeforeAfterTest.java
similarity index 72%
rename from ebean-test/src/test/java/org/test/ForTestsBeforeAfterTest.java
rename to ebean-test/src/test/java/org/etest/ForTestsBeforeAfterTest.java
index 7392b117d..70ad19ead 100644
--- a/ebean-test/src/test/java/org/test/ForTestsBeforeAfterTest.java
+++ b/ebean-test/src/test/java/org/etest/ForTestsBeforeAfterTest.java
@@ -1,11 +1,11 @@
-package org.test;
+package org.etest;
 
 import io.ebean.DB;
 import io.ebean.annotation.Transactional;
 import io.ebean.test.ForTests;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -14,12 +14,12 @@ public class ForTestsBeforeAfterTest {
 
   private ForTests.RollbackAll rollbackAll;
 
-  @Before
+  @BeforeEach
   public void before() {
     rollbackAll = ForTests.createRollbackAll();
   }
 
-  @After
+  @AfterEach
   public void after() {
     rollbackAll.close();
     assertThat(getCount()).isEqualTo(0);
@@ -34,7 +34,7 @@ public class ForTestsBeforeAfterTest {
   }
 
   private int getCount() {
-    return DB.find(BSimpleWithGen.class)
+    return DB.find(BSimpleFor.class)
         .where().eq("name", "ForTestsBeforeAfterTest")
         .findCount();
   }
@@ -42,7 +42,7 @@ public class ForTestsBeforeAfterTest {
   @Transactional
   private void doInsert() {
 
-    BSimpleWithGen bean = new BSimpleWithGen("ForTestsBeforeAfterTest");
+    BSimpleFor bean = new BSimpleFor("ForTestsBeforeAfterTest");
     DB.save(bean);
   }
 
diff --git a/ebean-test/src/test/java/org/test/ForTestsTest.java b/ebean-test/src/test/java/org/etest/ForTestsTest.java
similarity index 81%
rename from ebean-test/src/test/java/org/test/ForTestsTest.java
rename to ebean-test/src/test/java/org/etest/ForTestsTest.java
index bdf766ce9..b2b0804cb 100644
--- a/ebean-test/src/test/java/org/test/ForTestsTest.java
+++ b/ebean-test/src/test/java/org/etest/ForTestsTest.java
@@ -1,10 +1,10 @@
-package org.test;
+package org.etest;
 
 import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.Transactional;
 import io.ebean.test.ForTests;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -36,18 +36,18 @@ public class ForTestsTest {
   @Test
   public void rollbackTransactions() {
 
-    DB.find(BSimpleWithGen.class).delete();
+    DB.find(BSimpleFor.class).delete();
 
     ForTests.rollbackAll(this::doInsert);
 
-    final int count = DB.find(BSimpleWithGen.class).findCount();
+    final int count = DB.find(BSimpleFor.class).findCount();
     assertThat(count).isEqualTo(0);
   }
 
   @Transactional
   private void doInsert() {
 
-    BSimpleWithGen bean = new BSimpleWithGen("doInsert");
+    BSimpleFor bean = new BSimpleFor("doInsert");
     DB.save(bean);
   }
 
diff --git a/ebean-test/src/test/java/org/test/PlainBean.java b/ebean-test/src/test/java/org/etest/PlainBean.java
similarity index 95%
rename from ebean-test/src/test/java/org/test/PlainBean.java
rename to ebean-test/src/test/java/org/etest/PlainBean.java
index 103e67425..a86ba2c9f 100644
--- a/ebean-test/src/test/java/org/test/PlainBean.java
+++ b/ebean-test/src/test/java/org/etest/PlainBean.java
@@ -1,4 +1,4 @@
-package org.test;
+package org.etest;
 
 import java.util.Objects;
 
diff --git a/ebean-core/src/test/java/org/multitenant/partition/CurrentTenant.java b/ebean-test/src/test/java/org/multitenant/partition/CurrentTenant.java
similarity index 100%
rename from ebean-core/src/test/java/org/multitenant/partition/CurrentTenant.java
rename to ebean-test/src/test/java/org/multitenant/partition/CurrentTenant.java
diff --git a/ebean-core/src/test/java/org/multitenant/partition/MtBaseDomain.java b/ebean-test/src/test/java/org/multitenant/partition/MtBaseDomain.java
similarity index 100%
rename from ebean-core/src/test/java/org/multitenant/partition/MtBaseDomain.java
rename to ebean-test/src/test/java/org/multitenant/partition/MtBaseDomain.java
diff --git a/ebean-core/src/test/java/org/multitenant/partition/MtContent.java b/ebean-test/src/test/java/org/multitenant/partition/MtContent.java
similarity index 100%
rename from ebean-core/src/test/java/org/multitenant/partition/MtContent.java
rename to ebean-test/src/test/java/org/multitenant/partition/MtContent.java
diff --git a/ebean-core/src/test/java/org/multitenant/partition/MtTenant.java b/ebean-test/src/test/java/org/multitenant/partition/MtTenant.java
similarity index 100%
rename from ebean-core/src/test/java/org/multitenant/partition/MtTenant.java
rename to ebean-test/src/test/java/org/multitenant/partition/MtTenant.java
diff --git a/ebean-core/src/test/java/org/multitenant/partition/MtTenantAware.java b/ebean-test/src/test/java/org/multitenant/partition/MtTenantAware.java
similarity index 100%
rename from ebean-core/src/test/java/org/multitenant/partition/MtTenantAware.java
rename to ebean-test/src/test/java/org/multitenant/partition/MtTenantAware.java
diff --git a/ebean-core/src/test/java/org/multitenant/partition/MultiTenantPartitionTest.java b/ebean-test/src/test/java/org/multitenant/partition/MultiTenantPartitionTest.java
similarity index 86%
rename from ebean-core/src/test/java/org/multitenant/partition/MultiTenantPartitionTest.java
rename to ebean-test/src/test/java/org/multitenant/partition/MultiTenantPartitionTest.java
index 5076ce1c1..4e962ae92 100644
--- a/ebean-core/src/test/java/org/multitenant/partition/MultiTenantPartitionTest.java
+++ b/ebean-test/src/test/java/org/multitenant/partition/MultiTenantPartitionTest.java
@@ -5,9 +5,9 @@ import io.ebean.Database;
 import io.ebean.DatabaseFactory;
 import io.ebean.config.DatabaseConfig;
 import io.ebean.config.TenantMode;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.AfterClass;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -32,7 +32,7 @@ public class MultiTenantPartitionTest extends BaseTestCase {
     server.saveAll(tenants());
   }
 
-  @AfterClass
+  @AfterAll
   public static void shutdown() {
     server.shutdown();
   }
@@ -42,25 +42,25 @@ public class MultiTenantPartitionTest extends BaseTestCase {
 
     UserContext.set("rob", "ten_1");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     MtContent content = new MtContent("first title");
     server.save(content);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertSql(sql.get(0)).contains("insert into mt_content (title, body, when_modified, when_created, version, tenant_id) values (?,?,?,?,?,?)");
 
     content.setBody("some body");
     server.save(content);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertSql(sql.get(0)).contains("update mt_content set body=?, when_modified=?, version=? where id=? and tenant_id=? and version=?");
 
     server.delete(content);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertSql(sql.get(0)).contains("delete from mt_content where id=? and tenant_id=? and version=?");
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 
   @Test
@@ -71,10 +71,10 @@ public class MultiTenantPartitionTest extends BaseTestCase {
     MtContent content = new MtContent("first title");
     server.save(content);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     int rows = server.delete(MtContent.class, content.getId());
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("delete from mt_content where id=? and tenant_id=?");
     assertThat(rows).isEqualTo(1);
 
@@ -93,11 +93,11 @@ public class MultiTenantPartitionTest extends BaseTestCase {
 
     List<Long> ids = Arrays.asList(a.getId(), b.getId(), 99998L);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     int rows = server.deleteAll(MtContent.class, ids);
     assertThat(rows).isEqualTo(2);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("delete from mt_content where id=? and tenant_id=?");
   }
 
diff --git a/ebean-core/src/test/java/org/multitenant/partition/UserContext.java b/ebean-test/src/test/java/org/multitenant/partition/UserContext.java
similarity index 100%
rename from ebean-core/src/test/java/org/multitenant/partition/UserContext.java
rename to ebean-test/src/test/java/org/multitenant/partition/UserContext.java
diff --git a/ebean-core/src/test/java/org/tests/aggregateformula/IAFBaseSegment.java b/ebean-test/src/test/java/org/tests/aggregateformula/IAFBaseSegment.java
similarity index 50%
rename from ebean-core/src/test/java/org/tests/aggregateformula/IAFBaseSegment.java
rename to ebean-test/src/test/java/org/tests/aggregateformula/IAFBaseSegment.java
index 798fd7fd3..32b65492a 100644
--- a/ebean-core/src/test/java/org/tests/aggregateformula/IAFBaseSegment.java
+++ b/ebean-test/src/test/java/org/tests/aggregateformula/IAFBaseSegment.java
@@ -1,10 +1,6 @@
 package org.tests.aggregateformula;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Inheritance
diff --git a/ebean-core/src/test/java/org/tests/aggregateformula/IAFPartialSegment.java b/ebean-test/src/test/java/org/tests/aggregateformula/IAFPartialSegment.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/aggregateformula/IAFPartialSegment.java
rename to ebean-test/src/test/java/org/tests/aggregateformula/IAFPartialSegment.java
diff --git a/ebean-core/src/test/java/org/tests/aggregateformula/IAFSegmentStatus.java b/ebean-test/src/test/java/org/tests/aggregateformula/IAFSegmentStatus.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/aggregateformula/IAFSegmentStatus.java
rename to ebean-test/src/test/java/org/tests/aggregateformula/IAFSegmentStatus.java
diff --git a/ebean-core/src/test/java/org/tests/aggregateformula/TestAggregateFormula.java b/ebean-test/src/test/java/org/tests/aggregateformula/TestAggregateFormula.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/aggregateformula/TestAggregateFormula.java
rename to ebean-test/src/test/java/org/tests/aggregateformula/TestAggregateFormula.java
index ff9bfb70a..c51e7ff58 100644
--- a/ebean-core/src/test/java/org/tests/aggregateformula/TestAggregateFormula.java
+++ b/ebean-test/src/test/java/org/tests/aggregateformula/TestAggregateFormula.java
@@ -1,21 +1,17 @@
 package org.tests.aggregateformula;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
-import org.tests.model.basic.Address;
-import org.tests.model.basic.Contact;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.ResetBasicData;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestAggregateFormula extends BaseTestCase {
 
@@ -25,15 +21,15 @@ public class TestAggregateFormula extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Contact> contacts = Ebean.find(Contact.class)
+    List<Contact> contacts = DB.find(Contact.class)
       .setDistinct(true)
       .select("lastName, min(customer)")
       .order("min(customer) asc nulls last")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select distinct t0.last_name, min(t0.customer_id) from contact t0 group by t0.last_name order by min(t0.customer_id) nulls last");
 
     assertThat(contacts).isNotEmpty();
@@ -49,13 +45,13 @@ public class TestAggregateFormula extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Contact> contacts = Ebean.find(Contact.class)
+    List<Contact> contacts = DB.find(Contact.class)
       .select("lastName, min(customer)")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select t0.last_name, min(t0.customer_id) from contact t0 group by t0.last_name");
 
     assertThat(contacts).isNotEmpty();
@@ -71,9 +67,9 @@ public class TestAggregateFormula extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Contact> contacts = Ebean.find(Contact.class)
+    List<Contact> contacts = DB.find(Contact.class)
       .select("lastName, min(customer)")
       .fetchQuery("customer", "name, status")
       .findList();
@@ -81,10 +77,9 @@ public class TestAggregateFormula extends BaseTestCase {
     for (Contact contact : contacts) {
       Customer customer = contact.getCustomer();
       assertNotNull(customer.getName());
-      assertNotNull(customer.getStatus());
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.last_name, min(t0.customer_id) from contact t0 group by t0.last_name");
     assertSql(sql.get(1)).contains("select t0.id, t0.name, t0.status from o_customer t0 where");
@@ -101,9 +96,9 @@ public class TestAggregateFormula extends BaseTestCase {
   public void minOnManyToOne_withFetchQueryWithJoin() {
 
     ResetBasicData.reset();
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Contact> contacts = Ebean.find(Contact.class)
+    List<Contact> contacts = DB.find(Contact.class)
       .select("lastName, min(customer)")
       .fetchQuery("customer", "name, status")
       .fetch("customer.billingAddress", "city, country")
@@ -112,14 +107,13 @@ public class TestAggregateFormula extends BaseTestCase {
     for (Contact contact : contacts) {
       Customer customer = contact.getCustomer();
       assertNotNull(customer.getName());
-      assertNotNull(customer.getStatus());
       final Address billingAddress = customer.getBillingAddress();
       if (billingAddress != null) {
         assertNotNull(billingAddress.getCountry());
       }
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.last_name, min(t0.customer_id) from contact t0 group by t0.last_name");
     assertSql(sql.get(1)).contains("select t0.id, t0.name, t0.status, t1.id, t1.city, t1.country_code from o_customer t0 left join o_address t1 on t1.id = t0.billing_address_id where");
@@ -137,13 +131,13 @@ public class TestAggregateFormula extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Order> orders = Ebean.find(Order.class)
+    List<Order> orders = DB.find(Order.class)
       .select("status, sum(id)")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select t0.status, sum(t0.id) from o_order t0 group by t0.status");
 
     assertThat(orders).isNotEmpty();
@@ -158,13 +152,13 @@ public class TestAggregateFormula extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Order> orders = Ebean.find(Order.class)
+    List<Order> orders = DB.find(Order.class)
       .select("status, sum(id) as id")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select t0.status, sum(t0.id) id from o_order t0 group by t0.status");
 
     assertThat(orders).isNotEmpty();
@@ -179,13 +173,13 @@ public class TestAggregateFormula extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Contact> contacts = Ebean.find(Contact.class)
+    List<Contact> contacts = DB.find(Contact.class)
       .select("customer, min(cretime)")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select t0.customer_id, min(t0.cretime) from contact t0 group by t0.customer_id");
 
     assertThat(contacts).isNotEmpty();
@@ -196,13 +190,13 @@ public class TestAggregateFormula extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Contact> contacts = Ebean.find(Contact.class)
+    List<Contact> contacts = DB.find(Contact.class)
       .select("customer, min(cretime), max(updtime)")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select t0.customer_id, min(t0.cretime), max(t0.updtime) from contact t0 group by t0.customer_id");
 
     assertThat(contacts).isNotEmpty();
diff --git a/ebean-core/src/test/java/org/tests/aggregateformula/TestAggregateInheritFormula.java b/ebean-test/src/test/java/org/tests/aggregateformula/TestAggregateInheritFormula.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/aggregateformula/TestAggregateInheritFormula.java
rename to ebean-test/src/test/java/org/tests/aggregateformula/TestAggregateInheritFormula.java
index fd15df520..f7f9a3df7 100644
--- a/ebean-core/src/test/java/org/tests/aggregateformula/TestAggregateInheritFormula.java
+++ b/ebean-test/src/test/java/org/tests/aggregateformula/TestAggregateInheritFormula.java
@@ -2,8 +2,8 @@ package org.tests.aggregateformula;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 import java.util.List;
@@ -24,7 +24,7 @@ public class TestAggregateInheritFormula extends BaseTestCase {
 
     DB.saveAll(Arrays.asList(st0, st1, p0, p1));
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<IAFPartialSegment> segments =
       DB.find(IAFPartialSegment.class)
@@ -32,7 +32,7 @@ public class TestAggregateInheritFormula extends BaseTestCase {
         .where().eq("segmentIdZat", 108L)
         .findList();
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
 
     assertThat(segments).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.segment_id_zat, min(t0.status_id) from iaf_segment t0 where t0.ptype = 'target' and t0.segment_id_zat = ? group by t0.segment_id_zat");
diff --git a/ebean-core/src/test/java/org/tests/basic/MainDbBoolean.java b/ebean-test/src/test/java/org/tests/basic/MainDbBoolean.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/basic/MainDbBoolean.java
rename to ebean-test/src/test/java/org/tests/basic/MainDbBoolean.java
index 9db84d2c1..a45243287 100644
--- a/ebean-core/src/test/java/org/tests/basic/MainDbBoolean.java
+++ b/ebean-test/src/test/java/org/tests/basic/MainDbBoolean.java
@@ -1,32 +1,34 @@
 package org.tests.basic;
 
-import io.ebean.EbeanServer;
-import io.ebean.EbeanServerFactory;
+import io.ebean.Database;
+import io.ebean.DatabaseFactory;
 import io.ebean.Query;
 import io.ebean.SqlRow;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
 import io.ebean.datasource.DataSourceConfig;
-import org.junit.Assert;
 import org.tests.model.basic.TOne;
 import org.tests.model.basic.TSDetail;
 import org.tests.model.basic.TSMaster;
 
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 /**
  * Used to run some tests manually on a specific Database type.
  */
 public class MainDbBoolean {
 
   public static void main(String[] args) {
-
     MainDbBoolean me = new MainDbBoolean();
 
-    EbeanServer server = me.createEbeanServer();
+    Database server = me.createEbeanServer();
     me.simpleCheck(server);
 
-    EbeanServer oraServer = me.createOracleEbeanServer();
+    Database oraServer = me.createOracleEbeanServer();
     me.simpleCheck(oraServer);
   }
 
@@ -34,9 +36,8 @@ public class MainDbBoolean {
    * Create a server for running small oracle specific tests manually.
    * DDL generation etc.
    */
-  private EbeanServer createOracleEbeanServer() {
-
-    ServerConfig c = new ServerConfig();
+  private Database createOracleEbeanServer() {
+    DatabaseConfig c = new DatabaseConfig();
     c.setName("ora");
     c.setDdlExtra(false);
 
@@ -65,13 +66,11 @@ public class MainDbBoolean {
     c.addClass(TSMaster.class);
     c.addClass(TSDetail.class);
 
-    return EbeanServerFactory.create(c);
-
+    return DatabaseFactory.create(c);
   }
 
-  private EbeanServer createEbeanServer() {
-
-    ServerConfig c = new ServerConfig();
+  private Database createEbeanServer() {
+    DatabaseConfig c = new DatabaseConfig();
     c.setName("pgtest");
     c.setDdlExtra(false);
 
@@ -96,15 +95,11 @@ public class MainDbBoolean {
     c.setDatabaseBooleanFalse("F");
 
     c.setDatabasePlatform(new PostgresPlatform());
-
     c.addClass(TOne.class);
-
-    return EbeanServerFactory.create(c);
-
+    return DatabaseFactory.create(c);
   }
 
-  private void simpleCheck(EbeanServer server) {
-
+  private void simpleCheck(Database server) {
     TOne o = new TOne();
     o.setName("banan");
     o.setDescription("this one is true");
@@ -125,27 +120,24 @@ public class MainDbBoolean {
       .order("id")
       .findList();
 
-    Assert.assertTrue(list.size() == 2);
-    Assert.assertTrue(list.get(0).isActive());
-    Assert.assertFalse(!list.get(0).isActive());
+    assertThat(list).hasSize(2);
+    assertTrue(list.get(0).isActive());
 
     String sql = "select id, name, active from t_oneb order by id";
     List<SqlRow> sqlRows = server.sqlQuery(sql).findList();
-    Assert.assertTrue(sqlRows.size() == 2);
+    assertThat(sqlRows).hasSize(2);
     Object active0 = sqlRows.get(0).get("active");
     Object active1 = sqlRows.get(1).get("active");
 
-    Assert.assertTrue("T".equals(active0));
-    Assert.assertTrue("F".equals(active1));
-
+    assertEquals("T", active0);
+    assertEquals("F", active1);
 
     Query<TOne> query = server.find(TOne.class)
       .setAutoTune(false)
       .order("id");
 
     int rc = query.findCount();
-    Assert.assertTrue(rc > 0);
-
+    assertThat(rc).isGreaterThan(0);
 
     System.out.println("done");
   }
diff --git a/ebean-core/src/test/java/org/tests/basic/MyTestDataSourcePoolListener.java b/ebean-test/src/test/java/org/tests/basic/MyTestDataSourcePoolListener.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/basic/MyTestDataSourcePoolListener.java
rename to ebean-test/src/test/java/org/tests/basic/MyTestDataSourcePoolListener.java
diff --git a/ebean-core/src/test/java/org/tests/basic/TestAnnotationBase.java b/ebean-test/src/test/java/org/tests/basic/TestAnnotationBase.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/basic/TestAnnotationBase.java
rename to ebean-test/src/test/java/org/tests/basic/TestAnnotationBase.java
index c5781174d..547483ceb 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestAnnotationBase.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestAnnotationBase.java
@@ -8,7 +8,7 @@ import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanProperty;
 import io.ebeaninternal.server.deploy.IndexDefinition;
 import io.ebeaninternal.server.deploy.meta.DeployBeanProperty;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.ValidationGroupSomething;
 
 import javax.persistence.Entity;
@@ -25,9 +25,7 @@ import java.util.Set;
 
 import static io.ebean.annotation.Platform.H2;
 import static io.ebean.annotation.Platform.POSTGRES;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 
 public class TestAnnotationBase extends BaseTestCase {
@@ -210,28 +208,28 @@ public class TestAnnotationBase extends BaseTestCase {
 
   @Test
   public void testFindMaxSize() throws SecurityException {
-    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestAnnotationBaseEntity.class);
+    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().descriptor(TestAnnotationBaseEntity.class);
     BeanProperty bp = descriptor.findProperty("constraintAnnotation");
-    assertEquals(40, bp.getDbLength());
+    assertEquals(40, bp.dbLength());
   }
 
   @Test
   public void testFindJakartaMaxSize() throws SecurityException {
-    BeanDescriptor<TestJakartaAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestJakartaAnnotationBaseEntity.class);
+    BeanDescriptor<TestJakartaAnnotationBaseEntity> descriptor = spiEbeanServer().descriptor(TestJakartaAnnotationBaseEntity.class);
     BeanProperty bp = descriptor.findProperty("constraintAnnotation");
-    assertEquals(40, bp.getDbLength());
+    assertEquals(40, bp.dbLength());
   }
 
   @Test
   public void annotationClassIndexes() throws SecurityException {
-    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestAnnotationBaseEntity.class);
-    final IndexDefinition[] indexDefinitions = descriptor.getIndexDefinitions();
+    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().descriptor(TestAnnotationBaseEntity.class);
+    final IndexDefinition[] indexDefinitions = descriptor.indexDefinitions();
     assertEquals(3, indexDefinitions.length);
   }
 
   @Test
   public void testNotNullWithGroup() throws SecurityException {
-    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestAnnotationBaseEntity.class);
+    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().descriptor(TestAnnotationBaseEntity.class);
 
     BeanProperty bp = descriptor.findProperty("null1");
     assertFalse(bp.isNullable());
@@ -245,7 +243,7 @@ public class TestAnnotationBase extends BaseTestCase {
 
   @Test
   public void testJakartaNotNullWithGroup() throws SecurityException {
-    BeanDescriptor<TestJakartaAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestJakartaAnnotationBaseEntity.class);
+    BeanDescriptor<TestJakartaAnnotationBaseEntity> descriptor = spiEbeanServer().descriptor(TestJakartaAnnotationBaseEntity.class);
 
     BeanProperty bp = descriptor.findProperty("null1");
     assertFalse(bp.isNullable());
diff --git a/ebean-core/src/test/java/org/tests/basic/TestAssocOneEqExpression.java b/ebean-test/src/test/java/org/tests/basic/TestAssocOneEqExpression.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/basic/TestAssocOneEqExpression.java
rename to ebean-test/src/test/java/org/tests/basic/TestAssocOneEqExpression.java
index 77d987761..d32d86d4c 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestAssocOneEqExpression.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestAssocOneEqExpression.java
@@ -1,14 +1,15 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestAssocOneEqExpression extends BaseTestCase {
 
@@ -20,24 +21,24 @@ public class TestAssocOneEqExpression extends BaseTestCase {
     Customer c = new Customer();
     c.setId(1);
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .where().eq("customer", c)
       .query();
 
     query.findList();
     String sql = query.getGeneratedSql();
-    Assert.assertTrue(sql.contains("where t0.kcustomer_id = ?"));
+    assertTrue(sql.contains("where t0.kcustomer_id = ?"));
 
     Address b = new Address();
     b.setId(1);
 
-    Query<Order> q2 = Ebean.find(Order.class)
+    Query<Order> q2 = DB.find(Order.class)
       .where().eq("customer.billingAddress", b)
       .query();
 
     q2.findList();
     sql = q2.getGeneratedSql();
-    Assert.assertTrue(sql.contains("where t1.billing_address_id = ?"));
+    assertTrue(sql.contains("where t1.billing_address_id = ?"));
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestBatchLazy.java b/ebean-test/src/test/java/org/tests/basic/TestBatchLazy.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/basic/TestBatchLazy.java
rename to ebean-test/src/test/java/org/tests/basic/TestBatchLazy.java
index a81bf1596..a619cebce 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestBatchLazy.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestBatchLazy.java
@@ -1,13 +1,13 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -18,7 +18,7 @@ public class TestBatchLazy extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class);
+    Query<Order> query = DB.find(Order.class);
     List<Order> list = query.findList();
 
 
@@ -32,8 +32,8 @@ public class TestBatchLazy extends BaseTestCase {
       }
     }
 
-    Ebean.getDefaultServer().getAutoTune().collectProfiling();
-    Ebean.getDefaultServer().getAutoTune().reportProfiling();
+    DB.getDefault().autoTune().collectProfiling();
+    DB.getDefault().autoTune().reportProfiling();
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/basic/TestBatchLazyMany.java b/ebean-test/src/test/java/org/tests/basic/TestBatchLazyMany.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/basic/TestBatchLazyMany.java
rename to ebean-test/src/test/java/org/tests/basic/TestBatchLazyMany.java
index 8b29b6cb5..efe924f85 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestBatchLazyMany.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestBatchLazyMany.java
@@ -1,10 +1,10 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 public class TestBatchLazyMany extends BaseTestCase {
 
@@ -13,10 +13,10 @@ public class TestBatchLazyMany extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Order order2 = Ebean.getReference(Order.class, 1);
+    Order order2 = DB.reference(Order.class, 1);
     order2.getOrderDate();
 
-//		List<Order> list = Ebean.find(Order.class)
+//		List<Order> list = DB.find(Order.class)
 //			//.join("details")
 //			//.join("details", "+fetchquery")
 //			.findList();
diff --git a/ebean-test/src/test/java/org/tests/basic/TestBeanReferenceRefresh.java b/ebean-test/src/test/java/org/tests/basic/TestBeanReferenceRefresh.java
new file mode 100644
index 000000000..74e2441a5
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/basic/TestBeanReferenceRefresh.java
@@ -0,0 +1,53 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.cache.ServerCache;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Order.Status;
+import org.tests.model.basic.ResetBasicData;
+
+import java.sql.Date;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestBeanReferenceRefresh extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    ResetBasicData.reset();
+
+    ServerCache beanCache = DB.cacheManager().beanCache(Order.class);
+    beanCache.clear();
+
+    Order order = DB.reference(Order.class, 1);
+
+    assertTrue(DB.beanState(order).isReference());
+
+    // invoke lazy loading
+    Date orderDate = order.getOrderDate();
+    assertNotNull(orderDate);
+
+    Customer customer = order.getCustomer();
+    assertNotNull(customer);
+
+    assertFalse(DB.beanState(order).isReference());
+    assertNotNull(order.getStatus());
+    assertNotNull(order.getDetails());
+    assertNull(DB.beanState(order).loadedProps());
+
+    Status status = order.getStatus();
+    assertNotSame(status, Status.SHIPPED);
+    order.setStatus(Order.Status.SHIPPED);
+    DB.refresh(order);
+
+    Status statusRefresh = order.getStatus();
+    assertEquals(status, statusRefresh);
+
+  }
+
+
+}
diff --git a/ebean-core/src/test/java/org/tests/basic/TestCreateEntityBean.java b/ebean-test/src/test/java/org/tests/basic/TestCreateEntityBean.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/basic/TestCreateEntityBean.java
rename to ebean-test/src/test/java/org/tests/basic/TestCreateEntityBean.java
index af15e5380..4365d4860 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestCreateEntityBean.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestCreateEntityBean.java
@@ -2,14 +2,13 @@ package org.tests.basic;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EDefaultProp;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestCreateEntityBean extends BaseTestCase {
 
@@ -19,9 +18,9 @@ public class TestCreateEntityBean extends BaseTestCase {
 
     // Use `new` to construct EntityBean
     final EDefaultProp beanNew = new EDefaultProp();
-    Ebean.save(beanNew);
+    DB.save(beanNew);
 
-    final EDefaultProp beanNewDb = Ebean.find(EDefaultProp.class, beanNew.getId());
+    final EDefaultProp beanNewDb = DB.find(EDefaultProp.class, beanNew.getId());
     assertNotNull(beanNewDb);
     assertEquals("defaultName", beanNew.getName());
     assertNotNull(beanNewDb.geteSimple());
@@ -29,9 +28,9 @@ public class TestCreateEntityBean extends BaseTestCase {
 
     // Use `createEntityBean` to construct EntityBean and check if it behaves the same as `new`
     final EDefaultProp beanCreateEntityBean = DB.getDefault().createEntityBean(EDefaultProp.class);
-    Ebean.save(beanCreateEntityBean);
+    DB.save(beanCreateEntityBean);
 
-    final EDefaultProp beanCreateEntityBeanDb = Ebean.find(EDefaultProp.class, beanCreateEntityBean.getId());
+    final EDefaultProp beanCreateEntityBeanDb = DB.find(EDefaultProp.class, beanCreateEntityBean.getId());
     assertNotNull(beanCreateEntityBeanDb);
     assertEquals("defaultName", beanCreateEntityBeanDb.getName());
     assertNotNull(beanCreateEntityBeanDb.geteSimple());
diff --git a/ebean-core/src/test/java/org/tests/basic/TestDeleteByIdCollection.java b/ebean-test/src/test/java/org/tests/basic/TestDeleteByIdCollection.java
similarity index 54%
rename from ebean-core/src/test/java/org/tests/basic/TestDeleteByIdCollection.java
rename to ebean-test/src/test/java/org/tests/basic/TestDeleteByIdCollection.java
index d84b8caf4..ef0717cdb 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestDeleteByIdCollection.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestDeleteByIdCollection.java
@@ -1,17 +1,18 @@
 package org.tests.basic;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.TransactionalTestCase;
-
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
 public class TestDeleteByIdCollection extends TransactionalTestCase {
 
   @Test
@@ -22,14 +23,14 @@ public class TestDeleteByIdCollection extends TransactionalTestCase {
     Customer c0 = ResetBasicData.createCustomer("del1", "del1 ship", "del1 bill", 1);
     Customer c1 = ResetBasicData.createCustomer("del2", "del2 ship", "del2 bill", 2);
 
-    Ebean.save(c0);
-    Ebean.save(c1);
+    DB.save(c0);
+    DB.save(c1);
 
-    Customer c0Back = Ebean.find(Customer.class, c0.getId());
-    Customer c1Back = Ebean.find(Customer.class, "" + c1.getId());
+    Customer c0Back = DB.find(Customer.class, c0.getId());
+    Customer c1Back = DB.find(Customer.class, "" + c1.getId());
 
-    Assert.assertNotNull(c0Back);
-    Assert.assertNotNull(c1Back);
+    assertNotNull(c0Back);
+    assertNotNull(c1Back);
 
     List<String> ids = new ArrayList<>();
     // also test id type conversion
@@ -37,14 +38,14 @@ public class TestDeleteByIdCollection extends TransactionalTestCase {
     ids.add("" + c1.getId());
 
 
-    Ebean.deleteAll(Customer.class, ids);
+    DB.deleteAll(Customer.class, ids);
     awaitL2Cache();
 
-    c0Back = Ebean.find(Customer.class, c0.getId());
-    c1Back = Ebean.find(Customer.class, "" + c1.getId());
+    c0Back = DB.find(Customer.class, c0.getId());
+    c1Back = DB.find(Customer.class, "" + c1.getId());
 
-    Assert.assertNull(c0Back);
-    Assert.assertNull(c1Back);
+    assertNull(c0Back);
+    assertNull(c1Back);
   }
 
   @Test
@@ -55,11 +56,11 @@ public class TestDeleteByIdCollection extends TransactionalTestCase {
     Order order0 = ResetBasicData.createOrderCustAndOrder("delBySql 0");
     Order order1 = ResetBasicData.createOrderCustAndOrder("delBySql 1");
 
-    Order o0Back = Ebean.find(Order.class, order0.getId());
-    Order o1Back = Ebean.find(Order.class, order1.getId());
+    Order o0Back = DB.find(Order.class, order0.getId());
+    Order o1Back = DB.find(Order.class, order1.getId());
 
-    Assert.assertNotNull(o0Back);
-    Assert.assertNotNull(o1Back);
+    assertNotNull(o0Back);
+    assertNotNull(o1Back);
 
 
     List<Object> ids = new ArrayList<>();
@@ -67,14 +68,14 @@ public class TestDeleteByIdCollection extends TransactionalTestCase {
     ids.add(order0.getId());
     ids.add(order1.getId());
 
-    Ebean.deleteAll(Order.class, ids);
+    DB.deleteAll(Order.class, ids);
     awaitL2Cache();
 
-    o0Back = Ebean.find(Order.class, order0.getId());
-    o1Back = Ebean.find(Order.class, order1.getId());
+    o0Back = DB.find(Order.class, order0.getId());
+    o1Back = DB.find(Order.class, order1.getId());
 
-    Assert.assertNull(o0Back);
-    Assert.assertNull(o1Back);
+    assertNull(o0Back);
+    assertNull(o1Back);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestDeleteCascadingOneToMany.java b/ebean-test/src/test/java/org/tests/basic/TestDeleteCascadingOneToMany.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/basic/TestDeleteCascadingOneToMany.java
rename to ebean-test/src/test/java/org/tests/basic/TestDeleteCascadingOneToMany.java
index 770719f33..eabcbb380 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestDeleteCascadingOneToMany.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestDeleteCascadingOneToMany.java
@@ -2,7 +2,7 @@ package org.tests.basic;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Article;
 import org.tests.model.basic.Section;
 import org.tests.model.basic.SubSection;
diff --git a/ebean-core/src/test/java/org/tests/basic/TestDeleteImportedPartial.java b/ebean-test/src/test/java/org/tests/basic/TestDeleteImportedPartial.java
similarity index 53%
rename from ebean-core/src/test/java/org/tests/basic/TestDeleteImportedPartial.java
rename to ebean-test/src/test/java/org/tests/basic/TestDeleteImportedPartial.java
index 5ce7c6904..16ba29c32 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestDeleteImportedPartial.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestDeleteImportedPartial.java
@@ -1,11 +1,12 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.PFile;
 import org.tests.model.basic.PFileContent;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestDeleteImportedPartial extends BaseTestCase {
 
@@ -14,21 +15,20 @@ public class TestDeleteImportedPartial extends BaseTestCase {
 
     PFile persistentFile = new PFile("test.txt", new PFileContent("test".getBytes()));
 
-    Ebean.save(persistentFile);
+    DB.save(persistentFile);
     Integer id = persistentFile.getId();
     Integer contentId = persistentFile.getFileContent().getId();
 
-    PFile partialPfile = Ebean.find(PFile.class).select("id").where().idEq(persistentFile.getId())
+    PFile partialPfile = DB.find(PFile.class).select("id").where().idEq(persistentFile.getId())
       .findOne();
 
     // should delete file and fileContent
-    Ebean.delete(partialPfile);
+    DB.delete(partialPfile);
 
-    PFile file1 = Ebean.find(PFile.class, id);
-    PFileContent content1 = Ebean.find(PFileContent.class, contentId);
-
-    Assert.assertNull(file1);
-    Assert.assertNull(content1);
+    PFile file1 = DB.find(PFile.class, id);
+    PFileContent content1 = DB.find(PFileContent.class, contentId);
 
+    assertNull(file1);
+    assertNull(content1);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestDeleteOneToOne.java b/ebean-test/src/test/java/org/tests/basic/TestDeleteOneToOne.java
similarity index 60%
rename from ebean-core/src/test/java/org/tests/basic/TestDeleteOneToOne.java
rename to ebean-test/src/test/java/org/tests/basic/TestDeleteOneToOne.java
index 6f3151099..dfe431246 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestDeleteOneToOne.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestDeleteOneToOne.java
@@ -1,11 +1,12 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.PersistentFile;
 import org.tests.model.basic.PersistentFileContent;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestDeleteOneToOne extends BaseTestCase {
 
@@ -15,19 +16,18 @@ public class TestDeleteOneToOne extends BaseTestCase {
     PersistentFile persistentFile = new PersistentFile("test.txt", new PersistentFileContent(
       "test".getBytes()));
 
-    Ebean.save(persistentFile);
+    DB.save(persistentFile);
     Integer id = persistentFile.getId();
     Integer contentId = persistentFile.getPersistentFileContent().getId();
 
     // should delete file and fileContent
-    Ebean.delete(PersistentFile.class, id);
+    DB.delete(PersistentFile.class, id);
 
-    PersistentFile file1 = Ebean.find(PersistentFile.class, id);
-    PersistentFileContent content1 = Ebean.find(PersistentFileContent.class, contentId);
-
-    Assert.assertNull(file1);
-    Assert.assertNull(content1);
+    PersistentFile file1 = DB.find(PersistentFile.class, id);
+    PersistentFileContent content1 = DB.find(PersistentFileContent.class, contentId);
 
+    assertNull(file1);
+    assertNull(content1);
   }
 
   // public void testDeleteMany() {
@@ -38,13 +38,13 @@ public class TestDeleteOneToOne extends BaseTestCase {
   // c.addContact(new Contact("Fiona", "Black"));
   // c.addContact(new Contact("Tracy", "Red"));
   //
-  // Ebean.save(c);
+  // DB.save(c);
   //
-  // Ebean.delete(Customer.class, c.getId());
+  // DB.delete(Customer.class, c.getId());
   //
-  // Customer deletedCustomer = Ebean.find(Customer.class, c.getId());
+  // Customer deletedCustomer = DB.find(Customer.class, c.getId());
   //
-  // Assert.assertNull(deletedCustomer);
+  // assertNull(deletedCustomer);
   //
   // }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestDeleteOneToOneMultiple.java b/ebean-test/src/test/java/org/tests/basic/TestDeleteOneToOneMultiple.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/basic/TestDeleteOneToOneMultiple.java
rename to ebean-test/src/test/java/org/tests/basic/TestDeleteOneToOneMultiple.java
index fc4e38b01..433fb270c 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestDeleteOneToOneMultiple.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestDeleteOneToOneMultiple.java
@@ -1,11 +1,12 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.PFile;
 import org.tests.model.basic.PFileContent;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestDeleteOneToOneMultiple extends BaseTestCase {
 
@@ -19,19 +20,18 @@ public class TestDeleteOneToOneMultiple extends BaseTestCase {
 //    content.setContent("test".getBytes());
 //    persistentFile.setFileContent(content);
 
-    Ebean.save(persistentFile);
+    DB.save(persistentFile);
     Integer id = persistentFile.getId();
     Integer contentId = persistentFile.getFileContent().getId();
 
     // should delete file and fileContent
-    Ebean.delete(PFile.class, id);
+    DB.delete(PFile.class, id);
 
-    PFile file1 = Ebean.find(PFile.class, id);
-    PFileContent content1 = Ebean.find(PFileContent.class, contentId);
-
-    Assert.assertNull(file1);
-    Assert.assertNull(content1);
+    PFile file1 = DB.find(PFile.class, id);
+    PFileContent content1 = DB.find(PFileContent.class, contentId);
 
+    assertNull(file1);
+    assertNull(content1);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestDeletePartialNoVersion.java b/ebean-test/src/test/java/org/tests/basic/TestDeletePartialNoVersion.java
similarity index 65%
rename from ebean-core/src/test/java/org/tests/basic/TestDeletePartialNoVersion.java
rename to ebean-test/src/test/java/org/tests/basic/TestDeletePartialNoVersion.java
index 5a4e3468b..824f6bca3 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestDeletePartialNoVersion.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestDeletePartialNoVersion.java
@@ -1,10 +1,11 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TMapSuperEntity;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestDeletePartialNoVersion extends BaseTestCase {
 
@@ -14,20 +15,20 @@ public class TestDeletePartialNoVersion extends BaseTestCase {
     TMapSuperEntity e = new TMapSuperEntity();
     e.setName("babanaone");
 
-    Ebean.save(e);
+    DB.save(e);
 
     // select includes a transient property
-    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+    TMapSuperEntity e2 = DB.find(TMapSuperEntity.class)
       .where().idEq(e.getId())
       .select("id, name")
       .findOne();
 
-    Assert.assertNotNull(e2);
+    assertNotNull(e2);
 
     e2.setName("banaban2");
-    Ebean.save(e2);
+    DB.save(e2);
 
-    Ebean.delete(e2);
+    DB.delete(e2);
   }
 
 
@@ -36,19 +37,19 @@ public class TestDeletePartialNoVersion extends BaseTestCase {
     TMapSuperEntity e = new TMapSuperEntity();
     e.setName("babanatwo");
 
-    Ebean.save(e);
+    DB.save(e);
 
     // select includes a transient property
-    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+    TMapSuperEntity e2 = DB.find(TMapSuperEntity.class)
       .where().idEq(e.getId())
       .select("id, name, version")
       .findOne();
 
-    Assert.assertNotNull(e2);
+    assertNotNull(e2);
 
     e2.setName("banaban2two");
-    Ebean.save(e2);
+    DB.save(e2);
 
-    Ebean.delete(e2);
+    DB.delete(e2);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestDynamicUpdate.java b/ebean-test/src/test/java/org/tests/basic/TestDynamicUpdate.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/basic/TestDynamicUpdate.java
rename to ebean-test/src/test/java/org/tests/basic/TestDynamicUpdate.java
index ac6764edb..3b049591b 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestDynamicUpdate.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestDynamicUpdate.java
@@ -2,11 +2,12 @@ package org.tests.basic;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
 import org.tests.model.embedded.EMain;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestDynamicUpdate extends BaseTestCase {
 
@@ -18,27 +19,27 @@ public class TestDynamicUpdate extends BaseTestCase {
     b.setName("aaa");
     b.getEmbeddable().setDescription("123");
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     server.save(b);
 
-    Assert.assertNotNull(b.getId());
+    assertNotNull(b.getId());
 
     // reload object und update the name
     EMain b2 = server.find(EMain.class, b.getId());
 
     b2.getEmbeddable().setDescription("ABC");
 
-    BeanState beanState = server.getBeanState(b2);
+    BeanState beanState = server.beanState(b2);
     boolean dirty = beanState.isDirty();
-    Assert.assertTrue(dirty);
+    assertTrue(dirty);
 
     server.save(b2);
 
     server.beginTransaction();
     try {
       EMain b3 = server.find(EMain.class, b.getId());
-      Assert.assertEquals("ABC", b3.getEmbeddable().getDescription());
+      assertEquals("ABC", b3.getEmbeddable().getDescription());
     } finally {
       server.endTransaction();
     }
@@ -48,6 +49,6 @@ public class TestDynamicUpdate extends BaseTestCase {
     server.save(b4);
 
     EMain b5 = server.find(EMain.class, b.getId());
-    Assert.assertEquals("123", b5.getEmbeddable().getDescription());
+    assertEquals("123", b5.getEmbeddable().getDescription());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestEnhancementCollectionInitialisation.java b/ebean-test/src/test/java/org/tests/basic/TestEnhancementCollectionInitialisation.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/basic/TestEnhancementCollectionInitialisation.java
rename to ebean-test/src/test/java/org/tests/basic/TestEnhancementCollectionInitialisation.java
index 94895a77b..35c137540 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestEnhancementCollectionInitialisation.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestEnhancementCollectionInitialisation.java
@@ -2,27 +2,25 @@ package org.tests.basic;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 
 public class TestEnhancementCollectionInitialisation extends BaseTestCase {
 
   @Test
   public void testListInitialisation() {
-
     Customer customer = new Customer();
-    BeanState beanState = Ebean.getBeanState(customer);
+    BeanState beanState = DB.beanState(customer);
     if (beanState != null) {
       List<Order> orders = customer.getOrders();
-      Assert.assertNotNull(orders);
+      assertNotNull(orders);
     }
-
   }
-
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestErrorBindLog.java b/ebean-test/src/test/java/org/tests/basic/TestErrorBindLog.java
similarity index 55%
rename from ebean-core/src/test/java/org/tests/basic/TestErrorBindLog.java
rename to ebean-test/src/test/java/org/tests/basic/TestErrorBindLog.java
index 481f385ee..97b057392 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestErrorBindLog.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestErrorBindLog.java
@@ -1,28 +1,29 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 
 import javax.persistence.PersistenceException;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestErrorBindLog extends BaseTestCase {
 
   @Test
   public void test() {
 
     try {
-      Ebean.find(Order.class).where().gt("id", "JUNK").findList();
+      DB.find(Order.class).where().gt("id", "JUNK").findList();
 
     } catch (PersistenceException e) {
       String msg = e.getMessage();
       if (isHana()) {
-        Assert.assertTrue(msg.contains("Error with property[1] dt[12]data[JUNK]"));
+        assertTrue(msg.contains("Error with property[1] dt[12]data[JUNK]"));
       }
       else {
-        Assert.assertTrue(msg.contains("Bind values:"));
+        assertTrue(msg.contains("Bind values:"));
       }
     }
   }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestExplicitInsert.java b/ebean-test/src/test/java/org/tests/basic/TestExplicitInsert.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/basic/TestExplicitInsert.java
rename to ebean-test/src/test/java/org/tests/basic/TestExplicitInsert.java
index c6f8fb287..afc456e04 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestExplicitInsert.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestExplicitInsert.java
@@ -1,28 +1,27 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasic;
 import org.tests.model.basic.MyEBasicConfigStartup;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestExplicitInsert extends BaseTestCase {
 
   @Test
   public void setId_when_converted() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     Customer cust = new Customer();
-    Object returnId = server.setBeanId(cust, "42");
+    Object returnId = server.beanId(cust, "42");
 
     assertThat(returnId).isEqualTo(42);
     assertThat(cust.getId()).isEqualTo(42);
@@ -31,10 +30,10 @@ public class TestExplicitInsert extends BaseTestCase {
   @Test
   public void setId_when_correctType() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     Customer customer = new Customer();
-    Object returnId = server.setBeanId(customer, 42);
+    Object returnId = server.beanId(customer, 42);
 
     assertThat(returnId).isEqualTo(42);
     assertThat(customer.getId()).isEqualTo(42);
@@ -52,13 +51,10 @@ public class TestExplicitInsert extends BaseTestCase {
     b.setDescription("explicit insert");
     b.setStatus(EBasic.Status.ACTIVE);
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     server.insert(b);
-
-    Assert.assertNotNull(b.getId());
-
-    Assert.assertEquals(b.getId(), server.getBeanId(b));
-
+    assertNotNull(b.getId());
+    assertEquals(b.getId(), server.beanId(b));
 
     EBasic b2 = server.find(EBasic.class, b.getId());
     b2.setId(null);
@@ -66,8 +62,8 @@ public class TestExplicitInsert extends BaseTestCase {
     b2.setName("force insert");
     server.insert(b2);
 
-    Assert.assertNotNull(b2.getId());
-    Assert.assertTrue(!b.getId().equals(b2.getId()));
+    assertNotNull(b2.getId());
+    assertTrue(!b.getId().equals(b2.getId()));
 
     List<EBasic> list = server.find(EBasic.class).where().in("id", b.getId(), b2.getId()).findList();
 
diff --git a/ebean-core/src/test/java/org/tests/basic/TestFetchId.java b/ebean-test/src/test/java/org/tests/basic/TestFetchId.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/basic/TestFetchId.java
rename to ebean-test/src/test/java/org/tests/basic/TestFetchId.java
index c830208d5..2ebc4dab4 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestFetchId.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestFetchId.java
@@ -2,15 +2,12 @@ package org.tests.basic;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.FutureIds;
 import io.ebean.Query;
-import io.ebeantest.LoggedSql;
-
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 import java.util.concurrent.ExecutionException;
@@ -24,7 +21,7 @@ public class TestFetchId extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .setAutoTune(false)
       .fetch("details")
       .where().gt("id", 1)
@@ -40,16 +37,16 @@ public class TestFetchId extends BaseTestCase {
     List<Object> idList = futureIds.get();
     assertThat(idList).isNotEmpty();
   }
-  
+
   @Test
   public void testFetchIdWithExists() throws InterruptedException, ExecutionException {
 
     ResetBasicData.reset();
 
-    Query<OrderDetail> subQuery = Ebean.find(OrderDetail.class)
+    Query<OrderDetail> subQuery = DB.find(OrderDetail.class)
         .alias("sq")
         .where().raw("details.id = sq.id").query();
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .where().exists(subQuery)
       .orderBy("orderDate").query();
 
@@ -62,7 +59,7 @@ public class TestFetchId extends BaseTestCase {
     List<Object> idList = futureIds.get();
     assertThat(idList).isNotEmpty();
   }
-  
+
   @Test
   public void testFetchIdWithOrderFormula() throws InterruptedException, ExecutionException {
 
diff --git a/ebean-core/src/test/java/org/tests/basic/TestIUDVanilla.java b/ebean-test/src/test/java/org/tests/basic/TestIUDVanilla.java
similarity index 54%
rename from ebean-core/src/test/java/org/tests/basic/TestIUDVanilla.java
rename to ebean-test/src/test/java/org/tests/basic/TestIUDVanilla.java
index 82170e4a3..bdc902609 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestIUDVanilla.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestIUDVanilla.java
@@ -2,16 +2,14 @@ package org.tests.basic;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 import org.tests.model.basic.UTMaster;
 
 import javax.persistence.OptimisticLockException;
 import java.sql.Timestamp;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestIUDVanilla extends BaseTestCase {
 
@@ -22,8 +20,8 @@ public class TestIUDVanilla extends BaseTestCase {
 
     e0.save();
 
-    Assert.assertNotNull(e0.getId());
-    Assert.assertNotNull(e0.getLastUpdate());
+    assertNotNull(e0.getId());
+    assertNotNull(e0.getLastUpdate());
 
     Timestamp lastUpdate0 = e0.getLastUpdate();
 
@@ -31,8 +29,8 @@ public class TestIUDVanilla extends BaseTestCase {
     e0.save();
 
     Timestamp lastUpdate1 = e0.getLastUpdate();
-    Assert.assertNotNull(lastUpdate1);
-    Assert.assertNotSame(lastUpdate0, lastUpdate1);
+    assertNotNull(lastUpdate1);
+    assertNotSame(lastUpdate0, lastUpdate1);
 
     EBasicVer e2 = DB.getDefault().createEntityBean(EBasicVer.class);
 
@@ -72,36 +70,13 @@ public class TestIUDVanilla extends BaseTestCase {
     e3.update();
   }
 
-  @Test(expected = OptimisticLockException.class)
+  @Test
   public void modifyVersion_expect_optimisticLock() {
-
     UTMaster e0 = new UTMaster("save me");
     e0.save();
 
     // for this case we know 42 should throw OptimisticLockException
     e0.setVersion(42);
-    e0.update();
-  }
-
-  @Test
-  public void testOptimisticLockException() {
-    UTMaster e0 = new UTMaster("optLock");
-    DB.save(e0);
-
-    e0 = DB.find(UTMaster.class).where().eq("name", "optLock").findOne();
-    UTMaster e1 = DB.find(UTMaster.class).where().eq("name", "optLock").findOne();
-
-    int oldVersion = e0.getVersion();
-    e0.setDescription("foo");
-    e0.save();
-    assertThat(e0.getVersion()).isGreaterThan(oldVersion);
-
-    e1.setDescription("bar");
-    oldVersion = e1.getVersion();
-    assertThatThrownBy(e1::save).isInstanceOf(OptimisticLockException.class);
-    // after optimisticLockExecption, a restore of version is expected
-    assertThat(e1.getVersion()).isEqualTo(oldVersion);
-    // and subsequent saves must fail
-    assertThatThrownBy(e1::save).isInstanceOf(OptimisticLockException.class);
+    assertThrows(OptimisticLockException.class, () -> e0.update());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestInEmpty.java b/ebean-test/src/test/java/org/tests/basic/TestInEmpty.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/basic/TestInEmpty.java
rename to ebean-test/src/test/java/org/tests/basic/TestInEmpty.java
index 0da8d823a..a42667b7d 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestInEmpty.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestInEmpty.java
@@ -1,22 +1,21 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
-import org.junit.Test;
 
 import java.util.List;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestInEmpty extends BaseTestCase {
 
   @Test
   public void test_in_empty() {
 
-    Query<Order> query = Ebean.find(Order.class).where().in("id", new Object[0]).gt("id", 0)
+    Query<Order> query = DB.find(Order.class).where().in("id", new Object[0]).gt("id", 0)
       .query();
 
     List<Order> list = query.findList();
@@ -27,7 +26,7 @@ public class TestInEmpty extends BaseTestCase {
   @Test
   public void test_isIn_empty() {
 
-    Query<Order> query = Ebean.find(Order.class).where().isIn("id", new Object[0]).gt("id", 0)
+    Query<Order> query = DB.find(Order.class).where().isIn("id", new Object[0]).gt("id", 0)
       .query();
 
     List<Order> list = query.findList();
@@ -38,7 +37,7 @@ public class TestInEmpty extends BaseTestCase {
   @Test
   public void test_notIn_empty() {
 
-    Query<Order> query = Ebean.find(Order.class).where().notIn("id", new Object[0]).gt("id", 0)
+    Query<Order> query = DB.find(Order.class).where().notIn("id", new Object[0]).gt("id", 0)
       .query();
 
     query.findList();
diff --git a/ebean-core/src/test/java/org/tests/basic/TestInheritRef.java b/ebean-test/src/test/java/org/tests/basic/TestInheritRef.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/basic/TestInheritRef.java
rename to ebean-test/src/test/java/org/tests/basic/TestInheritRef.java
index e345bc8d3..c4b12d8e7 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestInheritRef.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestInheritRef.java
@@ -1,39 +1,41 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Car;
 import org.tests.model.basic.Truck;
 import org.tests.model.basic.Vehicle;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestInheritRef extends BaseTestCase {
 
   @Test
   public void testAssocOne() {
 
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
-      Ebean.createUpdate(Vehicle.class, "delete from vehicle");
+      DB.createUpdate(Vehicle.class, "delete from vehicle");
 
       Car c = new Car();
       c.setLicenseNumber("C6788");
       c.setDriver("CarDriver");
-      Ebean.save(c);
+      DB.save(c);
 
       Truck t = new Truck();
       t.setLicenseNumber("T1098BBX");
       t.setCapacity(20D);
-      Ebean.save(t);
+      DB.save(t);
 
-      List<Vehicle> list = Ebean.find(Vehicle.class)
+      List<Vehicle> list = DB.find(Vehicle.class)
         .setAutoTune(false)
         .findList();
 
-      Assert.assertTrue(!list.isEmpty());
+      assertTrue(!list.isEmpty());
 
       Truck foundTruck = null;
       int found = 0;
@@ -48,11 +50,11 @@ public class TestInheritRef extends BaseTestCase {
         }
       }
 
-      Assert.assertEquals(1, found);
-      Assert.assertTrue(foundTruck.getCapacity() == 20D);
+      assertEquals(1, found);
+      assertTrue(foundTruck.getCapacity() == 20D);
 
     } finally {
-      Ebean.rollbackTransaction();
+      DB.rollbackTransaction();
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestJodaType.java b/ebean-test/src/test/java/org/tests/basic/TestJodaType.java
similarity index 58%
rename from ebean-core/src/test/java/org/tests/basic/TestJodaType.java
rename to ebean-test/src/test/java/org/tests/basic/TestJodaType.java
index a7f76a3d7..30b98d23b 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestJodaType.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestJodaType.java
@@ -1,29 +1,29 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.core.type.ScalarType;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanProperty;
-import org.tests.model.basic.TJodaEntity;
 import org.joda.time.LocalTime;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.TJodaEntity;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestJodaType extends BaseTestCase {
 
   @Test
   public void test() {
 
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
-    BeanDescriptor<TJodaEntity> beanDescriptor = server.getBeanDescriptor(TJodaEntity.class);
-    BeanProperty beanProperty = beanDescriptor.getBeanProperty("localTime");
-    ScalarType<?> scalarType = beanProperty.getScalarType();
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
+    BeanDescriptor<TJodaEntity> beanDescriptor = server.descriptor(TJodaEntity.class);
+    BeanProperty beanProperty = beanDescriptor.beanProperty("localTime");
+    ScalarType<?> scalarType = beanProperty.scalarType();
 
-    Assert.assertNotNull(scalarType);
+    assertNotNull(scalarType);
   }
 
   @Test
@@ -33,9 +33,9 @@ public class TestJodaType extends BaseTestCase {
 
     TJodaEntity bean = new TJodaEntity();
     bean.setLocalTime(now);
-    Ebean.save(bean);
+    DB.save(bean);
 
-    TJodaEntity foundBean = Ebean.find(TJodaEntity.class, bean.getId());
+    TJodaEntity foundBean = DB.find(TJodaEntity.class, bean.getId());
 
     assertThat(foundBean.getLocalTime()).isEqualTo(bean.getLocalTime());
   }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestJoinInheritance.java b/ebean-test/src/test/java/org/tests/basic/TestJoinInheritance.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/basic/TestJoinInheritance.java
rename to ebean-test/src/test/java/org/tests/basic/TestJoinInheritance.java
index 0bfb8af45..70a2290c1 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestJoinInheritance.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestJoinInheritance.java
@@ -1,13 +1,9 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.tests.model.basic.Address;
-import org.tests.model.basic.Car;
-import org.tests.model.basic.Trip;
-import org.tests.model.basic.Vehicle;
-import org.tests.model.basic.VehicleDriver;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.sql.Timestamp;
 import java.util.Date;
@@ -32,7 +28,7 @@ public class TestJoinInheritance extends BaseTestCase {
   @Test
   public void testJoinHierarchyAssocOne() {
 
-    Ebean.createUpdate(Vehicle.class, "delete from vehicle");
+    DB.createUpdate(Vehicle.class, "delete from vehicle");
 
 
     Address address = new Address();
@@ -42,20 +38,20 @@ public class TestJoinInheritance extends BaseTestCase {
 
     address.setCretime(new Timestamp(new Date().getTime()));
 
-    Ebean.save(address);
+    DB.save(address);
 
     Car c = new Car();
     c.setLicenseNumber("C6788");
     c.setDriver("CarDriver");
     c.setRegistrationDate(new Date());
-    Ebean.save(c);
+    DB.save(c);
 
     VehicleDriver driver = new VehicleDriver();
 
     driver.setVehicle(c);
     driver.setAddress(address);
     driver.setLicenseIssuedOn(new Date());
-    Ebean.save(driver);
+    DB.save(driver);
 
     final String line1 = "Street1";
     final String line2 = "Street2";
@@ -67,13 +63,13 @@ public class TestJoinInheritance extends BaseTestCase {
       address1.setLine1(line1);
       address1.setLine2(line2);
       address1.setCity(city);
-      Ebean.save(address1);
+      DB.save(address1);
 
       Trip trip = new Trip();
       trip.setVehicleDriver(driver);
       trip.setAddress(address1);
       trip.setCretime(new Timestamp(new Date().getTime()));
-      Ebean.save(trip);
+      DB.save(trip);
     }
 
   }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestLazyLoadEmptyOneToMany.java b/ebean-test/src/test/java/org/tests/basic/TestLazyLoadEmptyOneToMany.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/basic/TestLazyLoadEmptyOneToMany.java
rename to ebean-test/src/test/java/org/tests/basic/TestLazyLoadEmptyOneToMany.java
index 4135d09aa..2bf0d083a 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestLazyLoadEmptyOneToMany.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestLazyLoadEmptyOneToMany.java
@@ -1,15 +1,16 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestLazyLoadEmptyOneToMany extends BaseTestCase {
 
   @Test
@@ -20,9 +21,9 @@ public class TestLazyLoadEmptyOneToMany extends BaseTestCase {
     Customer c = new Customer();
     c.setName("testll");
 
-    Ebean.save(c);
+    DB.save(c);
 
-    Customer c1 = Ebean.find(Customer.class)
+    Customer c1 = DB.find(Customer.class)
       .setAutoTune(false)
       .select("id")
       .fetch("contacts", "id")
@@ -32,9 +33,9 @@ public class TestLazyLoadEmptyOneToMany extends BaseTestCase {
     List<Contact> contacts = c1.getContacts();
     int sz = contacts.size();
 
-    Assert.assertTrue(sz == 0);
+    assertTrue(sz == 0);
 
     // cleanup
-    Ebean.delete(c1);
+    DB.delete(c1);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestLazyLoadInCache.java b/ebean-test/src/test/java/org/tests/basic/TestLazyLoadInCache.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/basic/TestLazyLoadInCache.java
rename to ebean-test/src/test/java/org/tests/basic/TestLazyLoadInCache.java
index 84512076a..6db645e15 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestLazyLoadInCache.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestLazyLoadInCache.java
@@ -3,8 +3,8 @@ package org.tests.basic;
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
 import io.ebean.CacheMode;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
@@ -12,8 +12,7 @@ import org.tests.model.basic.ResetBasicData;
 import java.util.Map;
 import java.util.Set;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestLazyLoadInCache extends BaseTestCase {
 
@@ -22,27 +21,27 @@ public class TestLazyLoadInCache extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Map<Integer, Customer> map = Ebean.find(Customer.class)
+    Map<Integer, Customer> map = DB.find(Customer.class)
       .select("id, name")
       .setBeanCacheMode(CacheMode.PUT)
       .setReadOnly(true)
       .order().asc("id")
       .findMap();
 
-    assertTrue(!map.isEmpty());
+    assertFalse(map.isEmpty());
 
     Object id = map.keySet().iterator().next();
 
     Customer cust1 = map.get(id);
 
-    Customer cust1B = Ebean.find(Customer.class)
+    Customer cust1B = DB.find(Customer.class)
       .setReadOnly(true)
       .setId(id)
       .findOne();
 
-    assertTrue(cust1 != cust1B);
+    assertNotSame(cust1, cust1B);
 
-    Set<String> loadedProps = Ebean.getBeanState(cust1).getLoadedProps();
+    Set<String> loadedProps = DB.beanState(cust1).loadedProps();
 
     assertTrue(loadedProps.contains("name"));
     assertFalse(loadedProps.contains("status"));
@@ -51,7 +50,7 @@ public class TestLazyLoadInCache extends BaseTestCase {
 
     // a readOnly reference
     Address billingAddress = cust1.getBillingAddress();
-    BeanState billAddrState = Ebean.getBeanState(billingAddress);
+    BeanState billAddrState = DB.beanState(billingAddress);
     assertTrue(billAddrState.isReference());
     assertTrue(billAddrState.isReadOnly());
 
diff --git a/ebean-core/src/test/java/org/tests/basic/TestLimitQuery.java b/ebean-test/src/test/java/org/tests/basic/TestLimitQuery.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/basic/TestLimitQuery.java
rename to ebean-test/src/test/java/org/tests/basic/TestLimitQuery.java
index 8b6fd2bc7..8d7eb92f0 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestLimitQuery.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestLimitQuery.java
@@ -1,16 +1,17 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 
 public class TestLimitQuery extends BaseTestCase {
@@ -26,7 +27,7 @@ public class TestLimitQuery extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .setAutoTune(false)
       .fetch("details")
       .where().gt("details.id", 0)
@@ -48,7 +49,7 @@ public class TestLimitQuery extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .setAutoTune(false)
       .fetch("details")
       .where().gt("details.id", 0)
@@ -62,8 +63,8 @@ public class TestLimitQuery extends BaseTestCase {
     boolean hasOffset = sql.contains("offset");
 
     if (isH2()) {
-      Assert.assertTrue(sql, hasLimit);
-      Assert.assertFalse(sql, hasOffset);
+      assertTrue(hasLimit);
+      assertFalse(hasOffset);
     }
   }
 
@@ -71,7 +72,7 @@ public class TestLimitQuery extends BaseTestCase {
   public void testDefaults() {
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .setAutoTune(false)
       .fetch("details")
       .where().gt("details.id", 0)
@@ -84,15 +85,15 @@ public class TestLimitQuery extends BaseTestCase {
     boolean hasOffset = sql.contains("offset");
 
     if (isH2()) {
-      Assert.assertFalse(hasLimit);
-      Assert.assertFalse(hasOffset);
+      assertFalse(hasLimit);
+      assertFalse(hasOffset);
     }
   }
 
   private void rob() {
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .setAutoTune(false)
       .fetch("details")
       .where().gt("details.id", 0)
@@ -101,7 +102,7 @@ public class TestLimitQuery extends BaseTestCase {
 
     List<Order> list = query.findList();
 
-    Assert.assertTrue("sz > 0", !list.isEmpty());
+    assertTrue(!list.isEmpty());
 
     String sql = query.getGeneratedSql();
     boolean hasDetailsJoin = sql.contains("join o_order_detail");
@@ -109,14 +110,14 @@ public class TestLimitQuery extends BaseTestCase {
     boolean hasSelectedDetails = sql.contains("od.id,");
     boolean hasDistinct = sql.contains("select distinct");
 
-    Assert.assertTrue(hasDetailsJoin);
-    Assert.assertFalse(hasSelectedDetails);
-    Assert.assertTrue(hasDistinct);
+    assertTrue(hasDetailsJoin);
+    assertFalse(hasSelectedDetails);
+    assertTrue(hasDistinct);
     if (isH2()) {
-      Assert.assertTrue(hasLimit);
+      assertTrue(hasLimit);
     }
 
-    query = Ebean.find(Order.class)
+    query = DB.find(Order.class)
       .setAutoTune(false)
       .fetch("details")
       .setMaxRows(10);
@@ -129,11 +130,11 @@ public class TestLimitQuery extends BaseTestCase {
     hasSelectedDetails = sql.contains("od.id");
     hasDistinct = sql.contains("select distinct");
 
-    Assert.assertFalse("no join with maxRows", hasDetailsJoin);
-    Assert.assertFalse(hasSelectedDetails);
-    Assert.assertFalse(hasDistinct);
+    assertFalse(hasDetailsJoin);
+    assertFalse(hasSelectedDetails);
+    assertFalse(hasDistinct);
     if (isH2()) {
-      Assert.assertTrue(hasLimit);
+      assertTrue(hasLimit);
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestLoadBeanCache.java b/ebean-test/src/test/java/org/tests/basic/TestLoadBeanCache.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/basic/TestLoadBeanCache.java
rename to ebean-test/src/test/java/org/tests/basic/TestLoadBeanCache.java
index 1962ddede..c96373de3 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestLoadBeanCache.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestLoadBeanCache.java
@@ -1,14 +1,15 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.Map;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestLoadBeanCache extends BaseTestCase {
 
   @Test
@@ -16,7 +17,7 @@ public class TestLoadBeanCache extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Map<String, Country> map = Ebean.find(Country.class)
+    Map<String, Country> map = DB.find(Country.class)
       .setLoadBeanCache(true)
       .setUseQueryCache(true)
       .setReadOnly(true)
@@ -26,8 +27,8 @@ public class TestLoadBeanCache extends BaseTestCase {
     Country loadedNz = map.get("NZ");
 
     // this will hit the cache
-    Country nz = Ebean.find(Country.class, "NZ");
+    Country nz = DB.find(Country.class, "NZ");
 
-    Assert.assertTrue(loadedNz == nz);
+    assertTrue(loadedNz == nz);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestLogTransLogOnError.java b/ebean-test/src/test/java/org/tests/basic/TestLogTransLogOnError.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/basic/TestLogTransLogOnError.java
rename to ebean-test/src/test/java/org/tests/basic/TestLogTransLogOnError.java
index 2c9b4b8cd..884571f8e 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestLogTransLogOnError.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestLogTransLogOnError.java
@@ -1,10 +1,9 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasicVer;
 import org.tests.model.basic.Order;
@@ -12,6 +11,9 @@ import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestLogTransLogOnError extends BaseTestCase {
 
   @Test
@@ -19,27 +21,27 @@ public class TestLogTransLogOnError extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    try (Transaction txn = Ebean.beginTransaction()) {
+    try (Transaction txn = DB.beginTransaction()) {
 
-      Ebean.find(Customer.class).findList();
-      Ebean.find(Order.class).where().gt("id", 1).findList();
+      DB.find(Customer.class).findList();
+      DB.find(Order.class).where().gt("id", 1).findList();
 
       EBasicVer newBean = new EBasicVer("aName");
       newBean.setDescription("something");
 
-      // Ebean.save(newBean);
+      // DB.save(newBean);
 
       // t.log("--- next query should error");
-      List<Customer> list = Ebean.find(Customer.class).where().eq("id", "NotAnInt!!").findList();
+      List<Customer> list = DB.find(Customer.class).where().eq("id", "NotAnInt!!").findList();
 
-      Assert.assertEquals(0, list.size());
+      assertEquals(0, list.size());
       // Get here with mysql?
-      // Assert.assertTrue(false);
+      // assertTrue(false);
       txn.commit();
 
     } catch (RuntimeException e) {
       // e.printStackTrace();
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
   }
 
@@ -47,8 +49,8 @@ public class TestLogTransLogOnError extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    try (Transaction txn = Ebean.beginTransaction()) {
-      Ebean.find(Customer.class).findList();
+    try (Transaction txn = DB.beginTransaction()) {
+      DB.find(Customer.class).findList();
 
       EBasicVer newBean = new EBasicVer("aName");
       newBean
@@ -58,15 +60,15 @@ public class TestLogTransLogOnError extends BaseTestCase {
           + "dfjksdjflsjdflsjdflksjdfkjd fsjdfkjsdkfjsdkfjskdjfskjdf sjdf sdjflksjdfkjsdlfkjsdkfjs ");
 
       // t.log("--- next insert should error");
-      Ebean.save(newBean);
+      DB.save(newBean);
 
       // never get here
-      Assert.assertTrue(false);
+      assertTrue(false);
       txn.commit();
 
     } catch (RuntimeException e) {
       // e.printStackTrace();
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestM2MCascadeOne.java b/ebean-test/src/test/java/org/tests/basic/TestM2MCascadeOne.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/basic/TestM2MCascadeOne.java
rename to ebean-test/src/test/java/org/tests/basic/TestM2MCascadeOne.java
index 851d8bc6b..5722ffbbb 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestM2MCascadeOne.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestM2MCascadeOne.java
@@ -1,11 +1,11 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MRole;
 import org.tests.model.basic.MUser;
-import org.junit.Test;
 
 public class TestM2MCascadeOne extends BaseTestCase {
 
@@ -16,28 +16,28 @@ public class TestM2MCascadeOne extends BaseTestCase {
     u.setUserName("testM2M");
 
     u.getRoles();
-    Ebean.save(u);
+    DB.save(u);
 
     MRole r0 = new MRole();
     r0.setRoleName("rol_0");
-    Ebean.save(r0);
+    DB.save(r0);
 
     MRole r1 = new MRole();
     r1.setRoleName("rol_1");
 
-    MUser u1 = Ebean.find(MUser.class, u.getUserid());
+    MUser u1 = DB.find(MUser.class, u.getUserid());
 
     u1.addRole(r0);
     u1.addRole(r1);
 
-    Ebean.save(u1);
+    DB.save(u1);
 
   }
 
   @Test
   public void testRawPredicate_with_ManyToManyPath() {
 
-    Query<MUser> query = Ebean.find(MUser.class)
+    Query<MUser> query = DB.find(MUser.class)
       .select("userid")
       .where().raw("roles.roleid in (?)", 24)
       .query();
diff --git a/ebean-core/src/test/java/org/tests/basic/TestM2MVanilla.java b/ebean-test/src/test/java/org/tests/basic/TestM2MVanilla.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/basic/TestM2MVanilla.java
rename to ebean-test/src/test/java/org/tests/basic/TestM2MVanilla.java
index 536ebd9b8..1f4e09106 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestM2MVanilla.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestM2MVanilla.java
@@ -3,20 +3,21 @@ package org.tests.basic;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MRole;
 import org.tests.model.basic.MUser;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestM2MVanilla extends BaseTestCase {
 
   @Test
   public void testVanilla() {
 
-    DB.createSqlUpdate("delete from mrole_muser").execute();
+    DB.sqlUpdate("delete from mrole_muser").execute();
     DB.sqlUpdate("delete from mrole").execute();
     DB.sqlUpdate("delete from muser").execute();
 
@@ -46,22 +47,22 @@ public class TestM2MVanilla extends BaseTestCase {
     user.setRoles(roleList);
 
     DB.save(user);
-    // Ebean.saveManyToManyAssociations(user, "roles");
+    // DB.saveManyToManyAssociations(user, "roles");
 
     MUser checkUser = DB.find(MUser.class, u0.getUserid());
     List<MRole> checkRoles = checkUser.getRoles();
-    Assert.assertNotNull(checkRoles);
-    Assert.assertEquals(2, checkRoles.size());
+    assertNotNull(checkRoles);
+    assertEquals(2, checkRoles.size());
 
     checkRoles.add(r3);
 
     DB.save(checkUser);
-    // Ebean.saveManyToManyAssociations(checkUser, "roles");
+    // DB.saveManyToManyAssociations(checkUser, "roles");
 
     MUser checkUser2 = DB.find(MUser.class, u0.getUserid());
     List<MRole> checkRoles2 = checkUser2.getRoles();
-    Assert.assertNotNull(checkRoles2);
-    Assert.assertEquals("added a role", 3, checkRoles2.size());
+    assertNotNull(checkRoles2);
+    assertEquals(3, checkRoles2.size());
 
     Query<MUser> rolesQuery0 = DB.find(MUser.class).where().eq("roles", r1).query();
 
@@ -70,7 +71,7 @@ public class TestM2MVanilla extends BaseTestCase {
     Query<MUser> rolesQuery = DB.find(MUser.class).where().in("roles", roleList).query();
 
     List<MUser> userInRolesList = rolesQuery.findList();
-    Assert.assertTrue(!userInRolesList.isEmpty());
+    assertTrue(!userInRolesList.isEmpty());
 
     List<MUser> list = DB.find(MUser.class)
       .where().in("roles", roleList)
@@ -79,7 +80,7 @@ public class TestM2MVanilla extends BaseTestCase {
 
     MUser mUser = list.get(0);
     List<MRole> roles = mUser.getRoles();
-    Assert.assertEquals(1, roles.size());
+    assertEquals(1, roles.size());
 
     checkRoles2.remove(0);
     checkRoles2.remove(0);
@@ -87,11 +88,10 @@ public class TestM2MVanilla extends BaseTestCase {
 
     checkUser2 = DB.find(MUser.class, u0.getUserid());
     checkRoles2 = checkUser2.getRoles();
-    Assert.assertNotNull(checkRoles2);
-    Assert.assertEquals("added a role", 1, checkRoles2.size());
+    assertNotNull(checkRoles2);
+    assertEquals(1, checkRoles2.size());
 
     DB.delete(checkUser2);
-
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestManyLazyLoad.java b/ebean-test/src/test/java/org/tests/basic/TestManyLazyLoad.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/basic/TestManyLazyLoad.java
rename to ebean-test/src/test/java/org/tests/basic/TestManyLazyLoad.java
index 3d1b932e2..10591aa09 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestManyLazyLoad.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestManyLazyLoad.java
@@ -1,16 +1,16 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.sql.Date;
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestManyLazyLoad extends BaseTestCase {
 
@@ -21,14 +21,14 @@ public class TestManyLazyLoad extends BaseTestCase {
 
     awaitL2Cache();
 
-    List<Order> list = Ebean.find(Order.class).order().asc("id").findList();
-    assertTrue(list.size() + " > 0", !list.isEmpty());
+    List<Order> list = DB.find(Order.class).order().asc("id").findList();
+    assertFalse(list.isEmpty());
 
     // just use the first one
     Order order = list.get(0);
 
     // get it as a reference
-    Order order1 = Ebean.getReference(Order.class, order.getId());
+    Order order1 = DB.reference(Order.class, order.getId());
     assertNotNull(order1);
 
     Date orderDate = order1.getOrderDate();
@@ -38,24 +38,24 @@ public class TestManyLazyLoad extends BaseTestCase {
 
     // lazy load the details
     int sz = details.size();
-    assertTrue(sz + " > 0", sz > 0);
+    assertTrue(sz > 0);
 
     OrderDetail orderDetail = details.get(0);
     Order o = orderDetail.getOrder();
     assertSame(o, order1);
 
     // load detail into cache
-    Ebean.find(OrderDetail.class, orderDetail.getId());
+    DB.find(OrderDetail.class, orderDetail.getId());
 
     // change order... list before a scalar property
-    Order order2 = Ebean.getReference(Order.class, order.getId());
+    Order order2 = DB.reference(Order.class, order.getId());
     assertNotNull(order2);
 
     List<OrderDetail> details2 = order2.getDetails();
 
     // lazy load the details
     int sz2 = details2.size();
-    assertTrue(sz2 + " > 0", sz2 > 0);
+    assertTrue(sz2 > 0);
 
     Order o2 = details2.get(0).getOrder();
     assertSame(o2, order2);
diff --git a/ebean-core/src/test/java/org/tests/basic/TestManyOneInterface.java b/ebean-test/src/test/java/org/tests/basic/TestManyOneInterface.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/basic/TestManyOneInterface.java
rename to ebean-test/src/test/java/org/tests/basic/TestManyOneInterface.java
index c27e6fc02..7f601523a 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestManyOneInterface.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestManyOneInterface.java
@@ -1,13 +1,13 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.ResetBasicData;
 import org.tests.model.interfaces.Address;
 import org.tests.model.interfaces.IAddress;
 import org.tests.model.interfaces.IPerson;
 import org.tests.model.interfaces.Person;
-import org.junit.Test;
 
 public class TestManyOneInterface extends BaseTestCase {
 
@@ -22,8 +22,8 @@ public class TestManyOneInterface extends BaseTestCase {
 
     p.setDefaultAddress(a);
 
-    Ebean.save(a);
-    Ebean.save(p);
+    DB.save(a);
+    DB.save(p);
 
     //Assert.assertTrue();
 
diff --git a/ebean-core/src/test/java/org/tests/basic/TestMappedSuper.java b/ebean-test/src/test/java/org/tests/basic/TestMappedSuper.java
similarity index 65%
rename from ebean-core/src/test/java/org/tests/basic/TestMappedSuper.java
rename to ebean-test/src/test/java/org/tests/basic/TestMappedSuper.java
index ae7340816..6c6f34fa1 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestMappedSuper.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestMappedSuper.java
@@ -1,10 +1,11 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TMapSuperEntity;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestMappedSuper extends BaseTestCase {
 
@@ -14,22 +15,22 @@ public class TestMappedSuper extends BaseTestCase {
     TMapSuperEntity e = new TMapSuperEntity();
     e.setName("babana");
 
-    Ebean.save(e);
+    DB.save(e);
 
     // select includes a transient property
-    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+    TMapSuperEntity e2 = DB.find(TMapSuperEntity.class)
       .where().idEq(e.getId())
       .select("id, name, myint, someObject, bananan")
       .findOne();
 
-    Assert.assertNotNull(e2);
+    assertNotNull(e2);
 
     TMapSuperEntity eSaveDelete = new TMapSuperEntity();
     eSaveDelete.setName("babana");
 
-    Ebean.save(eSaveDelete);
+    DB.save(eSaveDelete);
 
-    Ebean.delete(eSaveDelete);
+    DB.delete(eSaveDelete);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestMetaAnnotation.java b/ebean-test/src/test/java/org/tests/basic/TestMetaAnnotation.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/basic/TestMetaAnnotation.java
rename to ebean-test/src/test/java/org/tests/basic/TestMetaAnnotation.java
index f4638884e..71007df58 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestMetaAnnotation.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestMetaAnnotation.java
@@ -1,17 +1,17 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.annotation.Platform;
+import io.ebean.DB;
 import io.ebean.annotation.IgnorePlatform;
+import io.ebean.annotation.Platform;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.metaannotation.SizeMedium;
-import org.junit.Test;
 
 import javax.persistence.PersistenceException;
 
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Very simple test case to check if Ebean recognizes meta-annotation correctly.
@@ -31,7 +31,7 @@ public class TestMetaAnnotation extends BaseTestCase {
 
     Address address = new Address();
     address.setLine1(spaces100);
-    Ebean.save(address);
+    DB.save(address);
   }
 
   /**
@@ -42,7 +42,7 @@ public class TestMetaAnnotation extends BaseTestCase {
 
     Address address = new Address();
     address.setLine2(spaces100);
-    Ebean.save(address);
+    DB.save(address);
   }
 
   /**
@@ -55,7 +55,7 @@ public class TestMetaAnnotation extends BaseTestCase {
     Address address = new Address();
     address.setLine1(spaces101);
     try {
-      Ebean.save(address);
+      DB.save(address);
       fail("Test failed, Could insert a too long string");
     } catch (PersistenceException e) {
       assertTrue(true);
@@ -72,7 +72,7 @@ public class TestMetaAnnotation extends BaseTestCase {
     Address address = new Address();
     address.setLine2(spaces101);
     try {
-      Ebean.save(address);
+      DB.save(address);
       fail("Test failed, Could insert a too long string");
     } catch (PersistenceException e) {
       assertTrue(true);
diff --git a/ebean-core/src/test/java/org/tests/basic/TestMultipleOneToOneIUD.java b/ebean-test/src/test/java/org/tests/basic/TestMultipleOneToOneIUD.java
similarity index 51%
rename from ebean-core/src/test/java/org/tests/basic/TestMultipleOneToOneIUD.java
rename to ebean-test/src/test/java/org/tests/basic/TestMultipleOneToOneIUD.java
index 57a0a8fc2..3a9079788 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestMultipleOneToOneIUD.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestMultipleOneToOneIUD.java
@@ -1,14 +1,16 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.OCar;
 import org.tests.model.basic.OEngine;
 import org.tests.model.basic.OGearBox;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
 public class TestMultipleOneToOneIUD extends BaseTestCase {
 
   @Test
@@ -26,31 +28,31 @@ public class TestMultipleOneToOneIUD extends BaseTestCase {
     car.setName("test car");
     car.setEngine(engine);
 
-    try (Transaction txn = Ebean.beginTransaction()) {
-      Ebean.save(gearBox);
-      Ebean.save(car);
+    try (Transaction txn = DB.beginTransaction()) {
+      DB.save(gearBox);
+      DB.save(car);
 
-      Assert.assertNotNull(car.getId());
-      Assert.assertNotNull(engine.getEngineId());
-      Assert.assertNotNull(gearBox.getId());
+      assertNotNull(car.getId());
+      assertNotNull(engine.getEngineId());
+      assertNotNull(gearBox.getId());
       txn.commit();
     }
 
-    OCar c2 = Ebean.find(OCar.class, car.getId());
-    Assert.assertNotNull(c2);
-    Assert.assertNotNull(c2.getEngine());
+    OCar c2 = DB.find(OCar.class, car.getId());
+    assertNotNull(c2);
+    assertNotNull(c2.getEngine());
     // gearBox not assigned yet
-    Assert.assertNull(c2.getGearBox());
+    assertNull(c2.getGearBox());
 
     // ok, assign gearBox
     c2.setGearBox(gearBox);
-    Ebean.save(c2);
+    DB.save(c2);
 
     // now all should be there...
-    OCar c3 = Ebean.find(OCar.class, car.getId());
-    Assert.assertNotNull(c3);
-    Assert.assertNotNull(c3.getEngine());
-    Assert.assertNotNull(c3.getGearBox());
+    OCar c3 = DB.find(OCar.class, car.getId());
+    assertNotNull(c3);
+    assertNotNull(c3.getEngine());
+    assertNotNull(c3.getGearBox());
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestNonUpdateProperty.java b/ebean-test/src/test/java/org/tests/basic/TestNonUpdateProperty.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/basic/TestNonUpdateProperty.java
rename to ebean-test/src/test/java/org/tests/basic/TestNonUpdateProperty.java
index 08678b83d..030d4e3a4 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestNonUpdateProperty.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestNonUpdateProperty.java
@@ -1,9 +1,9 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MNonUpdPropEntity;
-import org.junit.Test;
 
 public class TestNonUpdateProperty extends BaseTestCase {
 
@@ -14,12 +14,12 @@ public class TestNonUpdateProperty extends BaseTestCase {
     e.setName("name");
     e.setNote("note");
 
-    Ebean.save(e);
+    DB.save(e);
 
-    MNonUpdPropEntity e2 = Ebean.find(MNonUpdPropEntity.class, e.getId());
+    MNonUpdPropEntity e2 = DB.find(MNonUpdPropEntity.class, e.getId());
 
     e2.setName("mod");
-    Ebean.update(e2);
+    DB.update(e2);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestOrderByAnnotation.java b/ebean-test/src/test/java/org/tests/basic/TestOrderByAnnotation.java
similarity index 61%
rename from ebean-core/src/test/java/org/tests/basic/TestOrderByAnnotation.java
rename to ebean-test/src/test/java/org/tests/basic/TestOrderByAnnotation.java
index 90ee62c0d..a552f0a92 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestOrderByAnnotation.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestOrderByAnnotation.java
@@ -1,17 +1,17 @@
 package org.tests.basic;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.TransactionalTestCase;
-
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestOrderByAnnotation extends TransactionalTestCase {
 
   @Test
@@ -19,19 +19,18 @@ public class TestOrderByAnnotation extends TransactionalTestCase {
 
     Customer custTest = ResetBasicData.createCustAndOrder("testOrderByAnn");
 
-    Customer customer = Ebean.find(Customer.class, custTest.getId());
+    Customer customer = DB.find(Customer.class, custTest.getId());
     List<Order> orders = customer.getOrders();
 
-    Assert.assertTrue(!orders.isEmpty());
+    assertTrue(!orders.isEmpty());
 
-
-    Query<Order> q1 = Ebean.find(Order.class)
+    Query<Order> q1 = DB.find(Order.class)
       .fetch("details");
 
     q1.findList();
 
     String s1 = q1.getGeneratedSql();
 
-    Assert.assertTrue(s1.contains("order by t0.id, t1.id asc, t1.order_qty asc, t1.cretime desc"));
+    assertTrue(s1.contains("order by t0.id, t1.id asc, t1.order_qty asc, t1.cretime desc"));
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountFormula.java b/ebean-test/src/test/java/org/tests/basic/TestOrderTotalAmountFormula.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountFormula.java
rename to ebean-test/src/test/java/org/tests/basic/TestOrderTotalAmountFormula.java
index 4a27102d4..2d8263759 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountFormula.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestOrderTotalAmountFormula.java
@@ -1,11 +1,11 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -16,7 +16,7 @@ public class TestOrderTotalAmountFormula extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> l0 = Ebean.find(Customer.class)
+    List<Customer> l0 = DB.find(Customer.class)
       .select("id, name")
       .fetch("orders", "status, totalAmount")
       .where()
diff --git a/ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountReportBean.java b/ebean-test/src/test/java/org/tests/basic/TestOrderTotalAmountReportBean.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountReportBean.java
rename to ebean-test/src/test/java/org/tests/basic/TestOrderTotalAmountReportBean.java
index 414e2c250..4de0887c7 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountReportBean.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestOrderTotalAmountReportBean.java
@@ -1,19 +1,13 @@
 package org.tests.basic;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.OrderAggregate;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestOrderTotalAmountReportBean extends BaseTestCase {
 
@@ -30,7 +24,7 @@ public class TestOrderTotalAmountReportBean extends BaseTestCase {
     RawSql rawSql = RawSqlBuilder.parse(sql).columnMapping("order_id", "order.id").create();
 
     List<OrderAggregate> l0 =
-      Ebean.find(OrderAggregate.class)
+      DB.find(OrderAggregate.class)
         .setRawSql(rawSql)
         .findList();
 
@@ -38,13 +32,13 @@ public class TestOrderTotalAmountReportBean extends BaseTestCase {
       r0.toString();
     }
 
-    List<OrderAggregate> l2 = Ebean.createQuery(OrderAggregate.class)
+    List<OrderAggregate> l2 = DB.createQuery(OrderAggregate.class)
       .setRawSql(rawSql)
       .where().gt("order.id", 0)
       .having().lt("totalItems", 3).gt("totalAmount", 50).findList();
 
     for (OrderAggregate r2 : l2) {
-      Assert.assertTrue(r2.getTotalItems() < 3);
+      assertTrue(r2.getTotalItems() < 3);
     }
 
   }
@@ -63,7 +57,7 @@ public class TestOrderTotalAmountReportBean extends BaseTestCase {
       .columnMapping("order_id", "order.id")
       .create();
 
-    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class)
+    Query<OrderAggregate> query = DB.find(OrderAggregate.class)
       .setRawSql(rawSql);
 
     query.findList();
@@ -85,7 +79,7 @@ public class TestOrderTotalAmountReportBean extends BaseTestCase {
       .columnMapping("order_id", "order.id")
       .create();
 
-    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class)
+    Query<OrderAggregate> query = DB.find(OrderAggregate.class)
       .setRawSql(rawSql);
 
     query.findList();
diff --git a/ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountSql.java b/ebean-test/src/test/java/org/tests/basic/TestOrderTotalAmountSql.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountSql.java
rename to ebean-test/src/test/java/org/tests/basic/TestOrderTotalAmountSql.java
index 9d6a26f36..2f647ac38 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountSql.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestOrderTotalAmountSql.java
@@ -3,12 +3,13 @@ package org.tests.basic;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.SqlRow;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestOrderTotalAmountSql extends BaseTestCase {
 
   @Test
@@ -22,8 +23,8 @@ public class TestOrderTotalAmountSql extends BaseTestCase {
     for (SqlRow sqlRow : sqlRows) {
       Integer id = sqlRow.getInteger("order_id");
       Double amount = sqlRow.getDouble("total_amount");
-      Assert.assertNotNull("sqlRows: " + sqlRows, id);
-      Assert.assertNotNull("sqlRows: " + sqlRows, amount);
+      assertNotNull(id);
+      assertNotNull(amount);
     }
   }
 
diff --git a/ebean-core/src/test/java/org/tests/basic/TestPersistenceContext.java b/ebean-test/src/test/java/org/tests/basic/TestPersistenceContext.java
similarity index 56%
rename from ebean-core/src/test/java/org/tests/basic/TestPersistenceContext.java
rename to ebean-test/src/test/java/org/tests/basic/TestPersistenceContext.java
index 2e786d5bb..e18c55c57 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestPersistenceContext.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestPersistenceContext.java
@@ -1,12 +1,14 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestPersistenceContext extends BaseTestCase {
 
@@ -17,63 +19,62 @@ public class TestPersistenceContext extends BaseTestCase {
 
     // implicit transaction with its own
     // persistence context
-    Order oBefore = Ebean.find(Order.class, 1);
+    Order oBefore = DB.find(Order.class, 1);
 
     Order order = null;
 
     // start a persistence context
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
 
-      order = Ebean.find(Order.class, 1);
+      order = DB.find(Order.class, 1);
 
       // not the same instance ...as a different
       // persistence context
-      Assert.assertTrue(order != oBefore);
+      assertTrue(order != oBefore);
 
 
       // finds an existing bean in the persistence context
       // ... so doesn't even execute a query
-      Order o2 = Ebean.find(Order.class, 1);
-      Order o3 = Ebean.getReference(Order.class, 1);
+      Order o2 = DB.find(Order.class, 1);
+      Order o3 = DB.reference(Order.class, 1);
 
       // all the same instance
-      Assert.assertTrue(order == o2);
-      Assert.assertTrue(order == o3);
+      assertTrue(order == o2);
+      assertTrue(order == o3);
 
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
 
     // implicit transaction with its own
     // persistence context
-    Order oAfter = Ebean.find(Order.class, 1);
+    Order oAfter = DB.find(Order.class, 1);
 
-    Assert.assertTrue(oAfter != oBefore);
-    Assert.assertTrue(oAfter != order);
+    assertTrue(oAfter != oBefore);
+    assertTrue(oAfter != order);
 
     // start a persistence context
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
       Order testOrder = ResetBasicData.createOrderCustAndOrder("testPC");
       Integer id = testOrder.getCustomer().getId();
       Integer orderId = testOrder.getId();
 
-      Customer customer = Ebean.find(Customer.class)
+      Customer customer = DB.find(Customer.class)
         .setUseCache(false)
         .setId(id)
         .findOne();
 
       System.gc();
-      Order order2 = Ebean.find(Order.class, orderId);
+      Order order2 = DB.find(Order.class, orderId);
       Customer customer2 = order2.getCustomer();
 
-      Assert.assertEquals(customer.getId(), customer2.getId());
-
-      Assert.assertTrue(customer == customer2);
+      assertEquals(customer.getId(), customer2.getId());
+      assertTrue(customer == customer2);
 
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
   }
 
diff --git a/ebean-core/src/test/java/org/tests/basic/TestQueryForUpdate.java b/ebean-test/src/test/java/org/tests/basic/TestQueryForUpdate.java
similarity index 62%
rename from ebean-core/src/test/java/org/tests/basic/TestQueryForUpdate.java
rename to ebean-test/src/test/java/org/tests/basic/TestQueryForUpdate.java
index ee224ccd5..527146367 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestQueryForUpdate.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestQueryForUpdate.java
@@ -1,23 +1,19 @@
 package org.tests.basic;
 
-import io.ebean.AcquireLockException;
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.Database;
-import io.ebean.Query;
-import io.ebean.Transaction;
+import io.ebean.*;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasic;
+import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryForUpdate extends BaseTestCase {
 
@@ -45,6 +41,69 @@ public class TestQueryForUpdate extends BaseTestCase {
     }
   }
 
+  @Test
+  @ForPlatform({ Platform.H2, Platform.ORACLE, Platform.POSTGRES, Platform.SQLSERVER, Platform.MYSQL, Platform.MARIADB})
+  public void testForUpdate_when_alreadyInPCAsReference() {
+    ResetBasicData.reset();
+    Order o0 = DB.find(Order.class).orderBy("id").setMaxRows(1).findOne();
+    Integer customerId = o0.getCustomer().getId();
+
+    try (Transaction transaction = DB.beginTransaction()) {
+
+      LoggedSql.start();
+      Order order = DB.find(Order.class, o0.getId());
+      assert order != null;
+
+      Customer customer = order.getCustomer();
+      assertTrue(DB.beanState(customer).isReference());
+      assertEquals(customerId, customer.getId());
+
+      Customer customer1 = DB.find(Customer.class).where().idEq(customer.getId()).forUpdate().findOne();
+
+      assertThat(customer).isSameAs(customer1);
+      assertThat(customer.getName()).isNotNull();
+
+      List<String> sql = LoggedSql.stop();
+      assertThat(sql).hasSize(2);
+      assertThat(sql.get(0)).contains("from o_order");
+      assertThat(sql.get(1)).contains("from o_customer t0 where t0.id = ?   for update");
+
+      transaction.commit();
+    }
+  }
+
+  @Test
+  @ForPlatform({ Platform.H2, Platform.ORACLE, Platform.POSTGRES, Platform.SQLSERVER, Platform.MYSQL, Platform.MARIADB})
+  public void testForUpdate_when_alreadyInPCAsReference_usingLock() {
+    ResetBasicData.reset();
+    Order o0 = DB.find(Order.class).orderBy("id").setMaxRows(1).findOne();
+    Integer customerId = o0.getCustomer().getId();
+
+    try (Transaction transaction = DB.beginTransaction()) {
+
+      LoggedSql.start();
+      Order order = DB.find(Order.class, o0.getId());
+      assert order != null;
+
+      Customer customer = order.getCustomer();
+      assertEquals(customerId, customer.getId());
+      assertTrue(DB.beanState(customer).isReference());
+
+      DB.lock(customer); // load the customer bean using select for update
+      // bean is now loaded and database row lock held until commit
+      assertFalse(DB.beanState(customer).isReference());
+
+      assertThat(customer.getName()).isNotNull();
+
+      List<String> sql = LoggedSql.stop();
+      assertThat(sql).hasSize(2);
+      assertThat(sql.get(0)).contains("from o_order");
+      assertThat(sql.get(1)).contains("from o_customer t0 where t0.id = ?   for update");
+
+      transaction.commit();
+    }
+  }
+
   @Test
   @ForPlatform({ Platform.H2, Platform.ORACLE, Platform.POSTGRES, Platform.SQLSERVER, Platform.MYSQL, Platform.MARIADB})
   public void testForUpdate_when_alreadyInPC() {
@@ -54,7 +113,7 @@ public class TestQueryForUpdate extends BaseTestCase {
 
     try (Transaction transaction = DB.beginTransaction()) {
 
-      LoggedSqlCollector.start();
+      LoggedSql.start();
 
       EBasic basic0 = DB.find(EBasic.class, basic.getId());
       assertThat(basic0).isNotNull();
@@ -67,7 +126,7 @@ public class TestQueryForUpdate extends BaseTestCase {
       assertThat(basic1).isNotNull();
       assertThat(basic1).isSameAs(basic0);
 
-      List<String> sql = LoggedSqlCollector.stop();
+      List<String> sql = LoggedSql.stop();
       assertThat(sql).hasSize(2);
       if (isH2() || isPostgres()) {
         assertSql(sql.get(0)).contains("from e_basic t0 where t0.id =");
diff --git a/ebean-core/src/test/java/org/tests/basic/TestQueryForUpdatePostgresLock.java b/ebean-test/src/test/java/org/tests/basic/TestQueryForUpdatePostgresLock.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/basic/TestQueryForUpdatePostgresLock.java
rename to ebean-test/src/test/java/org/tests/basic/TestQueryForUpdatePostgresLock.java
index ecda6bee2..a014c8b86 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestQueryForUpdatePostgresLock.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestQueryForUpdatePostgresLock.java
@@ -5,7 +5,7 @@ import io.ebean.DB;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.annotation.Transactional;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Article;
@@ -71,7 +71,7 @@ public class TestQueryForUpdatePostgresLock extends BaseTestCase {
     log.info("insert start");
     timePreInsert = System.currentTimeMillis();
     Section section = new Section();
-    section.setArticle(DB.getReference(Article.class, id));
+    section.setArticle(DB.reference(Article.class, id));
     DB.save(section);
     timePostInsert = System.currentTimeMillis();
     log.info("inserted");
diff --git a/ebean-core/src/test/java/org/tests/basic/TestQueryUsingConnection.java b/ebean-test/src/test/java/org/tests/basic/TestQueryUsingConnection.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/basic/TestQueryUsingConnection.java
rename to ebean-test/src/test/java/org/tests/basic/TestQueryUsingConnection.java
index 486d3a833..4e12f1bc5 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestQueryUsingConnection.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestQueryUsingConnection.java
@@ -2,11 +2,10 @@ package org.tests.basic;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Database;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.ResetBasicData;
 
@@ -15,7 +14,7 @@ import java.sql.Connection;
 import java.sql.SQLException;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestQueryUsingConnection extends BaseTestCase {
 
@@ -24,7 +23,7 @@ public class TestQueryUsingConnection extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    DataSource dataSource = DB.getDefault().getDataSource();
+    DataSource dataSource = DB.getDefault().dataSource();
 
     try (Connection connection = dataSource.getConnection()) {
 
diff --git a/ebean-core/src/test/java/org/tests/basic/TestQueryUsingDatabase.java b/ebean-test/src/test/java/org/tests/basic/TestQueryUsingDatabase.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/basic/TestQueryUsingDatabase.java
rename to ebean-test/src/test/java/org/tests/basic/TestQueryUsingDatabase.java
index 1648ed49c..54fa6b72a 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestQueryUsingDatabase.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestQueryUsingDatabase.java
@@ -2,9 +2,9 @@ package org.tests.basic;
 
 import io.ebean.DB;
 import io.ebean.Database;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.ESimple;
 
 import java.util.List;
@@ -17,13 +17,13 @@ public class TestQueryUsingDatabase {
   public static final ESimple RECORD1 = new ESimple();
   public static final ESimple RECORD2 = new ESimple();
 
-  @Before
+  @BeforeEach
   public void setupNonDefaultDatabase() {
     DB.byName(SOME_OTHER_DB_NAME).insert(RECORD1);
     DB.byName(SOME_OTHER_DB_NAME).insert(RECORD2);
   }
 
-  @After
+  @AfterEach
   public void shutdown() {
     DB.byName(SOME_OTHER_DB_NAME).shutdown();
   }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestQueryWhereBetween.java b/ebean-test/src/test/java/org/tests/basic/TestQueryWhereBetween.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/basic/TestQueryWhereBetween.java
rename to ebean-test/src/test/java/org/tests/basic/TestQueryWhereBetween.java
index aef27680e..ef755a30d 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestQueryWhereBetween.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestQueryWhereBetween.java
@@ -1,16 +1,17 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Assert;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
 import java.sql.Timestamp;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestQueryWhereBetween extends BaseTestCase {
 
   long statCount;
@@ -23,16 +24,16 @@ public class TestQueryWhereBetween extends BaseTestCase {
 
     Timestamp t = new Timestamp(System.currentTimeMillis());
 
-    Query<Order> query = Ebean.find(Order.class).setAutoTune(false).where()
+    Query<Order> query = DB.find(Order.class).setAutoTune(false).where()
       .betweenProperties("cretime", "updtime", t).order().asc("orderDate").order().desc("id");
 
     query.findList();
 
     String sql = query.getGeneratedSql();
-    Assert.assertTrue(sql.contains("between t0.cretime and t0.updtime"));
+    assertTrue(sql.contains("between t0.cretime and t0.updtime"));
   }
 
-  @Ignore
+  @Disabled
   @Test
   public void doStuff() {
 
@@ -87,7 +88,7 @@ public class TestQueryWhereBetween extends BaseTestCase {
 
     Timestamp t = new Timestamp(System.currentTimeMillis());
 
-    Query<Order> query = Ebean.find(Order.class).setAutoTune(false)
+    Query<Order> query = DB.find(Order.class).setAutoTune(false)
       .where()
       .le("cretime", t)
       .order().asc("orderDate")
diff --git a/ebean-core/src/test/java/org/tests/basic/TestQueryWhereInRange.java b/ebean-test/src/test/java/org/tests/basic/TestQueryWhereInRange.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/basic/TestQueryWhereInRange.java
rename to ebean-test/src/test/java/org/tests/basic/TestQueryWhereInRange.java
index 27b752231..03579c200 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestQueryWhereInRange.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestQueryWhereInRange.java
@@ -3,7 +3,7 @@ package org.tests.basic;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
diff --git a/ebean-core/src/test/java/org/tests/basic/TestQueryWithCache.java b/ebean-test/src/test/java/org/tests/basic/TestQueryWithCache.java
similarity index 54%
rename from ebean-core/src/test/java/org/tests/basic/TestQueryWithCache.java
rename to ebean-test/src/test/java/org/tests/basic/TestQueryWithCache.java
index 6e8208409..63dec52d1 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestQueryWithCache.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestQueryWithCache.java
@@ -1,19 +1,18 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheManager;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.core.CacheOptions;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryWithCache extends BaseTestCase {
 
@@ -22,33 +21,33 @@ public class TestQueryWithCache extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
-    BeanDescriptor<Country> beanDescriptor = server.getBeanDescriptor(Country.class);
-    CacheOptions cacheOptions = beanDescriptor.getCacheOptions();
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
+    BeanDescriptor<Country> beanDescriptor = server.descriptor(Country.class);
+    CacheOptions cacheOptions = beanDescriptor.cacheOptions();
 
     assertNotNull(cacheOptions);
     assertTrue(cacheOptions.isReadOnly());
     assertTrue(beanDescriptor.isCacheSharableBeans());
 
-    ServerCacheManager serverCacheManager = server.getServerCacheManager();
+    ServerCacheManager serverCacheManager = server.cacheManager();
     serverCacheManager.clear(Country.class);
 
-    ServerCache beanCache = serverCacheManager.getBeanCache(Country.class);
+    ServerCache beanCache = serverCacheManager.beanCache(Country.class);
     assertEquals(0, beanCache.size());
 
-    Country nz1 = Ebean.getReference(Country.class, "NZ");
+    Country nz1 = DB.reference(Country.class, "NZ");
     assertEquals(0, beanCache.size());
 
     // has the effect of loading the cache via lazy loading
     nz1.getName();
     assertEquals(1, beanCache.size());
 
-    Country nz2 = Ebean.getReference(Country.class, "NZ");
-    Country nz2b = Ebean.getReference(Country.class, "NZ");
+    Country nz2 = DB.reference(Country.class, "NZ");
+    Country nz2b = DB.reference(Country.class, "NZ");
 
-    Country nz3 = Ebean.find(Country.class, "NZ");
+    Country nz3 = DB.find(Country.class, "NZ");
 
-    Country nz4 = Ebean.find(Country.class).setId("NZ").setAutoTune(false).setUseCache(false)
+    Country nz4 = DB.find(Country.class).setId("NZ").setAutoTune(false).setUseCache(false)
       .findOne();
 
     assertTrue(nz2 == nz2b);
@@ -62,9 +61,9 @@ public class TestQueryWithCache extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Ebean.find(Country.class, "NZ");
+    DB.find(Country.class, "NZ");
 
-    Query<Country> query = Ebean.find(Country.class).setId("NZ").setUseCache(false);
+    Query<Country> query = DB.find(Country.class).setId("NZ").setUseCache(false);
     query.findOne();
 
     assertSql(query).isNotNull();
diff --git a/ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java b/ebean-test/src/test/java/org/tests/basic/TestReadOnlyPropagation.java
similarity index 52%
rename from ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java
rename to ebean-test/src/test/java/org/tests/basic/TestReadOnlyPropagation.java
index 4417e5451..c9b687fae 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestReadOnlyPropagation.java
@@ -1,89 +1,86 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.CacheMode;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.BeanCollection;
-import org.junit.Assert;
-import org.junit.Test;
-import org.tests.model.basic.Address;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.OrderDetail;
-import org.tests.model.basic.ResetBasicData;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestReadOnlyPropagation extends BaseTestCase {
 
   @Test
   public void testReadOnly() {
 
     ResetBasicData.reset();
+    DB.cacheManager().clearAll();
 
-    Order order = Ebean.find(Order.class)
-      .setAutoTune(false)
-      .setBeanCacheMode(CacheMode.OFF)
+    Order order = DB.find(Order.class)
       .setReadOnly(true)
       .setId(1)
       .findOne();
 
-    Assert.assertTrue(Ebean.getBeanState(order).isReadOnly());
+    assertTrue(DB.beanState(order).isReadOnly());
 
 
     Customer customer = order.getCustomer();
-    Assert.assertTrue(Ebean.getBeanState(customer).isReadOnly());
+    assertTrue(DB.beanState(customer).isReadOnly());
 
     Address billingAddress = customer.getBillingAddress();
-    Assert.assertTrue(Ebean.getBeanState(billingAddress).isReadOnly());
+    assertNotNull(billingAddress);
+    assertTrue(DB.beanState(billingAddress).isReadOnly());
 
 
     List<OrderDetail> details = order.getDetails();
     BeanCollection<?> bc = (BeanCollection<?>) details;
 
-    Assert.assertTrue(bc.isReadOnly());
-    Assert.assertTrue(!bc.isPopulated());
+    assertTrue(bc.isReadOnly());
+    assertTrue(!bc.isPopulated());
 
     bc.size();
-    Assert.assertTrue(!bc.isEmpty());
-    Assert.assertTrue(bc.isReadOnly());
-    Assert.assertTrue(bc.isPopulated());
+    assertTrue(!bc.isEmpty());
+    assertTrue(bc.isReadOnly());
+    assertTrue(bc.isPopulated());
     try {
       details.add(new OrderDetail());
-      Assert.assertTrue(false);
+      assertTrue(false);
     } catch (IllegalStateException e) {
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
     try {
       details.remove(0);
-      Assert.assertTrue(false);
+      assertTrue(false);
     } catch (IllegalStateException e) {
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
     try {
       Iterator<OrderDetail> it = details.iterator();
       it.next();
       it.remove();
-      Assert.assertTrue(false);
+      assertTrue(false);
     } catch (IllegalStateException e) {
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
     try {
       ListIterator<OrderDetail> it = details.listIterator();
       it.next();
       it.remove();
-      Assert.assertTrue(false);
+      assertTrue(false);
     } catch (IllegalStateException e) {
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
     try {
       List<OrderDetail> subList = details.subList(0, 1);
       subList.remove(0);
-      Assert.assertTrue(false);
+      assertTrue(false);
     } catch (UnsupportedOperationException e) {
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
 
 
diff --git a/ebean-core/src/test/java/org/tests/basic/TestSaveDeleteOneToOne.java b/ebean-test/src/test/java/org/tests/basic/TestSaveDeleteOneToOne.java
similarity index 62%
rename from ebean-core/src/test/java/org/tests/basic/TestSaveDeleteOneToOne.java
rename to ebean-test/src/test/java/org/tests/basic/TestSaveDeleteOneToOne.java
index 85b816b70..75208a534 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestSaveDeleteOneToOne.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestSaveDeleteOneToOne.java
@@ -1,11 +1,12 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.PersistentFile;
 import org.tests.model.basic.PersistentFileContent;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestSaveDeleteOneToOne extends BaseTestCase {
 
@@ -14,8 +15,8 @@ public class TestSaveDeleteOneToOne extends BaseTestCase {
     PersistentFile persistentFile = new PersistentFile("test.txt",
       new PersistentFileContent("test".getBytes()));
 
-    Ebean.save(persistentFile);
-    Ebean.delete(persistentFile);
+    DB.save(persistentFile);
+    DB.delete(persistentFile);
   }
 
   @Test
@@ -23,16 +24,15 @@ public class TestSaveDeleteOneToOne extends BaseTestCase {
     PersistentFile persistentFile = new PersistentFile("test.txt",
       new PersistentFileContent("test".getBytes()));
 
-    Ebean.save(persistentFile);
+    DB.save(persistentFile);
 
-    persistentFile = Ebean.find(PersistentFile.class, persistentFile.getId());
+    persistentFile = DB.find(PersistentFile.class, persistentFile.getId());
 
     PersistentFileContent persistentFileContent = persistentFile.getPersistentFileContent();
 
-    Assert.assertNotNull(persistentFileContent);
+    assertNotNull(persistentFileContent);
+    assertNotNull(persistentFileContent.getContent());
 
-    Assert.assertNotNull("load byte content", persistentFileContent.getContent());
-
-    Ebean.delete(persistentFile);
+    DB.delete(persistentFile);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestSaveDeleteOneToOneMultiple.java b/ebean-test/src/test/java/org/tests/basic/TestSaveDeleteOneToOneMultiple.java
similarity index 58%
rename from ebean-core/src/test/java/org/tests/basic/TestSaveDeleteOneToOneMultiple.java
rename to ebean-test/src/test/java/org/tests/basic/TestSaveDeleteOneToOneMultiple.java
index 91dd7fea9..e7e23283d 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestSaveDeleteOneToOneMultiple.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestSaveDeleteOneToOneMultiple.java
@@ -1,11 +1,12 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.PFile;
 import org.tests.model.basic.PFileContent;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestSaveDeleteOneToOneMultiple extends BaseTestCase {
 
@@ -13,8 +14,8 @@ public class TestSaveDeleteOneToOneMultiple extends BaseTestCase {
 //		PFile persistentFile = new PFile("test.txt",
 //				new PFileContent("test".getBytes()));
 //
-//		Ebean.save(persistentFile);
-//		Ebean.delete(persistentFile);
+//		DB.save(persistentFile);
+//		DB.delete(persistentFile);
 //	}
 
   @Test
@@ -22,16 +23,14 @@ public class TestSaveDeleteOneToOneMultiple extends BaseTestCase {
     PFile persistentFile = new PFile("test.txt",
       new PFileContent("test".getBytes()));
 
-    Ebean.save(persistentFile);
+    DB.save(persistentFile);
 
-    persistentFile = Ebean.find(PFile.class, persistentFile.getId());
+    persistentFile = DB.find(PFile.class, persistentFile.getId());
 
     PFileContent persistentFileContent = persistentFile.getFileContent();
 
-    Assert.assertNotNull(persistentFileContent);
-
-    Assert.assertNotNull("load byte content", persistentFileContent.getContent());
-
-    Ebean.delete(persistentFile);
+    assertNotNull(persistentFileContent);
+    assertNotNull(persistentFileContent.getContent());
+    DB.delete(persistentFile);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestSharedInstancePropagation.java b/ebean-test/src/test/java/org/tests/basic/TestSharedInstancePropagation.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/basic/TestSharedInstancePropagation.java
rename to ebean-test/src/test/java/org/tests/basic/TestSharedInstancePropagation.java
index 3f85c0486..bf98a2d00 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestSharedInstancePropagation.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestSharedInstancePropagation.java
@@ -1,17 +1,17 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.BeanCollection;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.Product;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestSharedInstancePropagation extends BaseTestCase {
 
@@ -24,9 +24,9 @@ public class TestSharedInstancePropagation extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Ebean.getServerCacheManager().clearAll();
+    DB.cacheManager().clearAll();
 
-    Order order = Ebean.find(Order.class)
+    Order order = DB.find(Order.class)
       .setAutoTune(false)
       .setReadOnly(true)
       .setId(1)
@@ -34,7 +34,7 @@ public class TestSharedInstancePropagation extends BaseTestCase {
 
 
     assertNotNull(order);
-    assertTrue(Ebean.getBeanState(order).isReadOnly());
+    assertTrue(DB.beanState(order).isReadOnly());
 
     List<OrderDetail> details = order.getDetails();
     BeanCollection<?> bc = (BeanCollection<?>) details;
@@ -48,16 +48,16 @@ public class TestSharedInstancePropagation extends BaseTestCase {
     assertTrue(!bc.isEmpty());
     OrderDetail detail = details.get(0);
 
-    assertTrue(Ebean.getBeanState(detail).isReadOnly());
-    assertFalse(Ebean.getBeanState(detail).isReference());
+    assertTrue(DB.beanState(detail).isReadOnly());
+    assertFalse(DB.beanState(detail).isReference());
 
     Product product = detail.getProduct();
 
-    assertTrue(Ebean.getBeanState(product).isReadOnly());
+    assertTrue(DB.beanState(product).isReadOnly());
 
     // lazy load
     product.getName();
-    assertFalse(Ebean.getBeanState(product).isReference());
+    assertFalse(DB.beanState(product).isReference());
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestTransient.java b/ebean-test/src/test/java/org/tests/basic/TestTransient.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/basic/TestTransient.java
rename to ebean-test/src/test/java/org/tests/basic/TestTransient.java
index 428896ac1..9edd48cac 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestTransient.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestTransient.java
@@ -3,17 +3,14 @@ package org.tests.basic;
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import java.sql.Types;
 import java.util.Optional;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestTransient extends BaseTestCase {
 
@@ -30,8 +27,8 @@ public class TestTransient extends BaseTestCase {
 
     assertNotNull(c);
 
-    BeanState beanState = DB.getBeanState(c);
-    assertFalse("not new or dirty as transient", beanState.isNewOrDirty());
+    BeanState beanState = DB.beanState(c);
+    assertFalse(beanState.isNewOrDirty());
 
     c.getLock().tryLock();
     try {
@@ -43,7 +40,7 @@ public class TestTransient extends BaseTestCase {
     Boolean selected = c.getSelected();
     assertNotNull(selected);
 
-    assertFalse("not new or dirty as transient", beanState.isNewOrDirty());
+    assertFalse(beanState.isNewOrDirty());
 
     DB.save(c);
 
@@ -51,13 +48,13 @@ public class TestTransient extends BaseTestCase {
     assertNotNull(selected);
 
     c.setName("Modified");
-    assertTrue("dirty now", beanState.isNewOrDirty());
+    assertTrue(beanState.isNewOrDirty());
 
     selected = c.getSelected();
     assertNotNull(selected);
 
     DB.save(c);
-    assertFalse("Not dirty after save", beanState.isNewOrDirty());
+    assertFalse(beanState.isNewOrDirty());
 
     selected = c.getSelected();
     assertNotNull(selected);
diff --git a/ebean-core/src/test/java/org/tests/basic/TestUpdateManyToOne.java b/ebean-test/src/test/java/org/tests/basic/TestUpdateManyToOne.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/basic/TestUpdateManyToOne.java
rename to ebean-test/src/test/java/org/tests/basic/TestUpdateManyToOne.java
index 1a86cdcde..c00635678 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestUpdateManyToOne.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestUpdateManyToOne.java
@@ -1,11 +1,11 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -16,9 +16,9 @@ public class TestUpdateManyToOne extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> custs = Ebean.find(Customer.class).findList();
+    List<Customer> custs = DB.find(Customer.class).findList();
 
-    List<Order> orders = Ebean.find(Order.class).setMaxRows(1).findList();
+    List<Order> orders = DB.find(Order.class).setMaxRows(1).findList();
 
     Order order = orders.get(0);
     Customer customer = order.getCustomer();
@@ -31,10 +31,10 @@ public class TestUpdateManyToOne extends BaseTestCase {
       }
     }
     order.setCustomer(changeCust);
-    Ebean.save(order);
+    DB.save(order);
 
     order.setCustomer(customer);
-    Ebean.save(order);
+    DB.save(order);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestUuidInsert.java b/ebean-test/src/test/java/org/tests/basic/TestUuidInsert.java
similarity index 62%
rename from ebean-core/src/test/java/org/tests/basic/TestUuidInsert.java
rename to ebean-test/src/test/java/org/tests/basic/TestUuidInsert.java
index b0ae3fcc2..95cfce6d1 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestUuidInsert.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestUuidInsert.java
@@ -1,9 +1,9 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TUuidEntity;
-import org.junit.Test;
 
 public class TestUuidInsert extends BaseTestCase {
 
@@ -13,13 +13,13 @@ public class TestUuidInsert extends BaseTestCase {
     TUuidEntity e = new TUuidEntity();
     e.setName("bana");
 
-    Ebean.save(e);
+    DB.save(e);
 
-    TUuidEntity e2 = Ebean.find(TUuidEntity.class, e.getId());
+    TUuidEntity e2 = DB.find(TUuidEntity.class, e.getId());
     e2.setName("apple");
 
-    Ebean.save(e2);
+    DB.save(e2);
 
-    Ebean.delete(e2);
+    DB.delete(e2);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestUuidInsertMasterDetail.java b/ebean-test/src/test/java/org/tests/basic/TestUuidInsertMasterDetail.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/basic/TestUuidInsertMasterDetail.java
rename to ebean-test/src/test/java/org/tests/basic/TestUuidInsertMasterDetail.java
index 49e49fc12..1c554e093 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestUuidInsertMasterDetail.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestUuidInsertMasterDetail.java
@@ -1,10 +1,10 @@
 package org.tests.basic;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UUOne;
 import org.tests.model.basic.UUTwo;
-import org.junit.Test;
 
 import java.util.ArrayList;
 
@@ -23,22 +23,22 @@ public class TestUuidInsertMasterDetail extends BaseTestCase {
     one.setName("some one");
     one.setComments(list);
 
-    Ebean.save(one);
+    DB.save(one);
 
-    UUOne oneB = Ebean.find(UUOne.class, one.getId());
+    UUOne oneB = DB.find(UUOne.class, one.getId());
 
     UUTwo twoB = new UUTwo();
     twoB.setName("another something");
     oneB.getComments().add(twoB);
 
-    Ebean.save(oneB);
+    DB.save(oneB);
   }
 
   public void testNullFK() {
 
     UUTwo two = new UUTwo();
     two.setName("something");
-    Ebean.save(two);
+    DB.save(two);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/TestWhereAnnotation.java b/ebean-test/src/test/java/org/tests/basic/TestWhereAnnotation.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/basic/TestWhereAnnotation.java
rename to ebean-test/src/test/java/org/tests/basic/TestWhereAnnotation.java
index 9bc32faf9..f0989b7ac 100644
--- a/ebean-core/src/test/java/org/tests/basic/TestWhereAnnotation.java
+++ b/ebean-test/src/test/java/org/tests/basic/TestWhereAnnotation.java
@@ -1,18 +1,17 @@
 package org.tests.basic;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.TransactionalTestCase;
-
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestWhereAnnotation extends TransactionalTestCase {
 
@@ -21,12 +20,12 @@ public class TestWhereAnnotation extends TransactionalTestCase {
 
     Customer custTest = ResetBasicData.createCustAndOrder("testWhereAnn");
 
-    Customer customer = Ebean.find(Customer.class, custTest.getId());
+    Customer customer = DB.find(Customer.class, custTest.getId());
     List<Order> orders = customer.getOrders();
 
-    Assert.assertTrue(!orders.isEmpty());
+    assertTrue(!orders.isEmpty());
 
-    Query<Customer> q1 = Ebean.find(Customer.class).setUseCache(false).fetch("orders").where()
+    Query<Customer> q1 = DB.find(Customer.class).setUseCache(false).fetch("orders").where()
       .idEq(1).query();
 
     q1.findOne();
diff --git a/ebean-test/src/test/java/org/tests/basic/delete/TestDeleteByIdList.java b/ebean-test/src/test/java/org/tests/basic/delete/TestDeleteByIdList.java
new file mode 100644
index 000000000..99197ac98
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/basic/delete/TestDeleteByIdList.java
@@ -0,0 +1,42 @@
+package org.tests.basic.delete;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class TestDeleteByIdList extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    OrderDetail dummy = DB.reference(OrderDetail.class, 1);
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
+    server.descriptor(OrderDetail.class).cacheBeanPut(dummy);
+
+    Customer c0 = ResetBasicData.createCustAndOrder("DelIdList-0");
+    assertNotNull(c0);
+
+    Customer c1 = ResetBasicData.createCustAndOrder("DelIdList-1");
+
+    List<Object> orderIds = DB.find(Order.class).where().in("customer", c0, c1).findIds();
+
+    assertEquals(2, orderIds.size());
+
+    DB.deleteAll(Order.class, orderIds);
+    DB.delete(c0);
+    DB.delete(c1);
+
+  }
+}
diff --git a/ebean-test/src/test/java/org/tests/basic/delete/TestDeleteCascadeById.java b/ebean-test/src/test/java/org/tests/basic/delete/TestDeleteCascadeById.java
new file mode 100644
index 000000000..17af48c3c
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/basic/delete/TestDeleteCascadeById.java
@@ -0,0 +1,42 @@
+package org.tests.basic.delete;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class TestDeleteCascadeById extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    OrderDetail dummy = DB.reference(OrderDetail.class, 1);
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
+    server.descriptor(OrderDetail.class).cacheBeanPut(dummy);
+
+    Customer cust = ResetBasicData.createCustAndOrder("DelCas");
+    assertNotNull(cust);
+
+    List<Order> orders = DB.find(Order.class).where().eq("customer", cust).findList();
+
+    assertEquals(1, orders.size());
+    Order o = orders.get(0);
+    assertNotNull(o);
+
+    // cleanup
+    DB.delete(o);
+    DB.delete(cust);
+
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/basic/delete/TestDeleteCascadeByQuery.java b/ebean-test/src/test/java/org/tests/basic/delete/TestDeleteCascadeByQuery.java
similarity index 64%
rename from ebean-core/src/test/java/org/tests/basic/delete/TestDeleteCascadeByQuery.java
rename to ebean-test/src/test/java/org/tests/basic/delete/TestDeleteCascadeByQuery.java
index 5da596325..5a101c208 100644
--- a/ebean-core/src/test/java/org/tests/basic/delete/TestDeleteCascadeByQuery.java
+++ b/ebean-test/src/test/java/org/tests/basic/delete/TestDeleteCascadeByQuery.java
@@ -1,62 +1,60 @@
 package org.tests.basic.delete;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.tests.model.onetoone.OtoUser;
 import org.tests.model.onetoone.OtoUserOptional;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class TestDeleteCascadeByQuery extends BaseTestCase {
-  
+
   private OtoUser testUser;
   private OtoUserOptional userOptional;
-  private Query<OtoUserOptional> userOptionalQuery = Ebean.find(OtoUserOptional.class);
-  private Query<OtoUser> userQuery = Ebean.find(OtoUser.class);
-  
+  private Query<OtoUserOptional> userOptionalQuery = DB.find(OtoUserOptional.class);
+  private Query<OtoUser> userQuery = DB.find(OtoUser.class);
+
   /**
    * Init each test. Delete all existing beans. Then create OtoUser, add OtoUserOptional and save.
    */
-  @Before
+  @BeforeEach
   public void init() {
-    Ebean.deleteAll(userQuery.findList());
-    Ebean.deleteAll(userOptionalQuery.findList());
-    
+    DB.deleteAll(userQuery.findList());
+    DB.deleteAll(userOptionalQuery.findList());
+
     userOptional = new OtoUserOptional();
-    Ebean.save(userOptional);
+    DB.save(userOptional);
     testUser = new OtoUser();
     testUser.setOptional(userOptional);
-    Ebean.save(testUser);
+    DB.save(testUser);
   }
-  
+
   /**
-   * Test that validates deleting a bean using Ebean.delete() respects the CascadeType.DELETE 
+   * Test that validates deleting a bean using DB.delete() respects the CascadeType.DELETE
    * setting.
    */
   @Test
   public void testDeleteCascadeByEbeanDelete() {
 
-    assertThat(Ebean.delete(testUser)).isTrue();
+    assertThat(DB.delete(testUser)).isTrue();
 
     assertThat(userOptionalQuery.findCount())
-      .overridingErrorMessage("Entity OtoUserOptional found. Ebean.delete() on the user "
+      .overridingErrorMessage("Entity OtoUserOptional found. DB.delete() on the user "
           + "did not delete the OneToOne mapped entity as set with CascadeType.ALL")
       .isEqualTo(0);
   }
-  
+
   /**
-   * Test that validates deleting a bean with OneToOne mapping with a query respects the 
+   * Test that validates deleting a bean with OneToOne mapping with a query respects the
    * CascadeType.DELETE setting.
    */
   @Test
   public void testDeleteCascadeByQuery() {
-    
+
     assertThat(userQuery.delete()).isEqualTo(1);
 
     assertThat(userOptionalQuery.findCount())
@@ -64,13 +62,13 @@ public class TestDeleteCascadeByQuery extends BaseTestCase {
           + "did not delete the OneToOne mapped entity as set with CascadeType.ALL")
       .isEqualTo(0);
   }
-  
+
   /**
    * Cleanup - Delete all existing beans for the next test.
    */
-  @After
+  @AfterEach
   public void cleanup() {
-    Ebean.deleteAll(userQuery.findList());
-    Ebean.deleteAll(userOptionalQuery.findList());
+    DB.deleteAll(userQuery.findList());
+    DB.deleteAll(userOptionalQuery.findList());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/encrypt/BasicEncryptKey.java b/ebean-test/src/test/java/org/tests/basic/encrypt/BasicEncryptKey.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/basic/encrypt/BasicEncryptKey.java
rename to ebean-test/src/test/java/org/tests/basic/encrypt/BasicEncryptKey.java
diff --git a/ebean-core/src/test/java/org/tests/basic/encrypt/BasicEncyptKeyManager.java b/ebean-test/src/test/java/org/tests/basic/encrypt/BasicEncyptKeyManager.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/basic/encrypt/BasicEncyptKeyManager.java
rename to ebean-test/src/test/java/org/tests/basic/encrypt/BasicEncyptKeyManager.java
diff --git a/ebean-core/src/test/java/org/tests/basic/encrypt/TestEncrypt.java b/ebean-test/src/test/java/org/tests/basic/encrypt/TestEncrypt.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/basic/encrypt/TestEncrypt.java
rename to ebean-test/src/test/java/org/tests/basic/encrypt/TestEncrypt.java
index fb80fcabb..143aa059c 100644
--- a/ebean-core/src/test/java/org/tests/basic/encrypt/TestEncrypt.java
+++ b/ebean-test/src/test/java/org/tests/basic/encrypt/TestEncrypt.java
@@ -6,9 +6,9 @@ import io.ebean.SqlRow;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.config.dbplatform.DbEncrypt;
+import io.ebean.test.LoggedSql;
 import io.ebeaninternal.api.SpiEbeanServer;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicEncrypt;
 import org.tests.model.basic.EBasicEncryptRelate;
 
@@ -16,7 +16,7 @@ import java.sql.Date;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestEncrypt extends BaseTestCase {
 
@@ -25,12 +25,12 @@ public class TestEncrypt extends BaseTestCase {
   @ForPlatform({Platform.H2, Platform.SQLSERVER}) // only run this on H2 - PGCrypto not happy on CI server
   public void testQueryBind() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.find(EBasicEncrypt.class)
       .where().startsWith("description", "Rob")
       .findList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("; --bind(****,Rob%)");
   }
@@ -39,7 +39,7 @@ public class TestEncrypt extends BaseTestCase {
   @ForPlatform({Platform.H2, Platform.SQLSERVER}) // only run this on H2 - PGCrypto not happy on CI server
   public void testQueryJoin() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.find(EBasicEncryptRelate.class)
       .where().eq("other.description", "foo")
@@ -49,7 +49,7 @@ public class TestEncrypt extends BaseTestCase {
       .where().eq("other.description", "foo")
       .findCount();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(2);
     assertThat(loggedSql.get(0)).contains("left join e_basicenc t1 on t1.id = t0.other_id");
     assertThat(loggedSql.get(1)).contains("left join e_basicenc t1 on t1.id = t0.other_id");
@@ -134,7 +134,7 @@ public class TestEncrypt extends BaseTestCase {
     assertEquals(EBasicEncrypt.Status.ONE, e2.getStatus());
 
     SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
-    DbEncrypt dbEncrypt = server.getDatabasePlatform().getDbEncrypt();
+    DbEncrypt dbEncrypt = server.databasePlatform().getDbEncrypt();
 
     if (dbEncrypt == null) {
       // can not test the where clause
diff --git a/ebean-core/src/test/java/org/tests/basic/encrypt/TestEncryptBinary.java b/ebean-test/src/test/java/org/tests/basic/encrypt/TestEncryptBinary.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/basic/encrypt/TestEncryptBinary.java
rename to ebean-test/src/test/java/org/tests/basic/encrypt/TestEncryptBinary.java
index 2a8e4224c..6c26ee0fe 100644
--- a/ebean-core/src/test/java/org/tests/basic/encrypt/TestEncryptBinary.java
+++ b/ebean-test/src/test/java/org/tests/basic/encrypt/TestEncryptBinary.java
@@ -3,12 +3,13 @@ package org.tests.basic.encrypt;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.SqlRow;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicEncryptBinary;
 
 import java.sql.Timestamp;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestEncryptBinary extends BaseTestCase {
 
   @Test
@@ -23,7 +24,7 @@ public class TestEncryptBinary extends BaseTestCase {
 
     DB.save(e);
 
-    SqlRow row = DB.createSqlQuery("select * from e_basicenc_bin where id = :id")
+    SqlRow row = DB.sqlQuery("select * from e_basicenc_bin where id = :id")
       .setParameter("id", e.getId())
       .findOne();
 
@@ -38,7 +39,7 @@ public class TestEncryptBinary extends BaseTestCase {
 
     e1.getDescription();
 
-    Assert.assertEquals(t0, t1);
+    assertEquals(t0, t1);
 
     e1.setName("testmod");
     e1.setDescription("moddesc");
diff --git a/ebean-core/src/test/java/org/tests/basic/encrypt/TestEncryptClientSide.java b/ebean-test/src/test/java/org/tests/basic/encrypt/TestEncryptClientSide.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/basic/encrypt/TestEncryptClientSide.java
rename to ebean-test/src/test/java/org/tests/basic/encrypt/TestEncryptClientSide.java
index e5d59a07b..ff941438b 100644
--- a/ebean-core/src/test/java/org/tests/basic/encrypt/TestEncryptClientSide.java
+++ b/ebean-test/src/test/java/org/tests/basic/encrypt/TestEncryptClientSide.java
@@ -1,8 +1,8 @@
 package org.tests.basic.encrypt;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicEncryptClient;
 
 import java.time.LocalDate;
@@ -21,9 +21,9 @@ public class TestEncryptClientSide extends BaseTestCase {
     bean.setStatus(EBasicEncryptClient.Status.ONE);
     bean.setDob(today);
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicEncryptClient found = Ebean.find(EBasicEncryptClient.class)
+    EBasicEncryptClient found = DB.find(EBasicEncryptClient.class)
       .where()
       .eq("description", "hello")
       .eq("status", EBasicEncryptClient.Status.ONE)
@@ -38,9 +38,9 @@ public class TestEncryptClientSide extends BaseTestCase {
 
     found.setDescription("goodbye");
     found.setStatus(EBasicEncryptClient.Status.TWO);
-    Ebean.save(found);
+    DB.save(found);
 
-    found = Ebean.find(EBasicEncryptClient.class)
+    found = DB.find(EBasicEncryptClient.class)
       .where()
       .eq("description", "goodbye")
       .eq("status", EBasicEncryptClient.Status.TWO)
@@ -50,6 +50,6 @@ public class TestEncryptClientSide extends BaseTestCase {
     assertThat(found).isNotNull();
     assertThat(found.getDescription()).isEqualTo("goodbye");
 
-    Ebean.delete(found);
+    DB.delete(found);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/event/TestPreInsertValidation.java b/ebean-test/src/test/java/org/tests/basic/event/TestPreInsertValidation.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/basic/event/TestPreInsertValidation.java
rename to ebean-test/src/test/java/org/tests/basic/event/TestPreInsertValidation.java
index 9b025b0c3..54f26782e 100644
--- a/ebean-core/src/test/java/org/tests/basic/event/TestPreInsertValidation.java
+++ b/ebean-test/src/test/java/org/tests/basic/event/TestPreInsertValidation.java
@@ -2,10 +2,11 @@ package org.tests.basic.event;
 
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TWithPreInsert;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestPreInsertValidation extends BaseTestCase {
 
@@ -16,16 +17,16 @@ public class TestPreInsertValidation extends BaseTestCase {
     e.setTitle("Mister");
     // the perInsert should populate the
     // name with should not be null
-    Ebean.save(e);
+    DB.save(e);
 
     // the save worked and name set in preInsert
-    Assert.assertNotNull(e.getId());
-    Assert.assertNotNull(e.getName());
+    assertNotNull(e.getId());
+    assertNotNull(e.getName());
 
-    TWithPreInsert e1 = Ebean.find(TWithPreInsert.class, e.getId());
+    TWithPreInsert e1 = DB.find(TWithPreInsert.class, e.getId());
 
     e1.setTitle("Missus");
-    Ebean.save(e1);
+    DB.save(e1);
   }
 
   @Test
@@ -33,17 +34,17 @@ public class TestPreInsertValidation extends BaseTestCase {
 
     TWithPreInsert e = new TWithPreInsert();
     e.setName("BeanForUpdateTest");
-    Ebean.save(e);
+    DB.save(e);
 
     TWithPreInsert bean2 = new TWithPreInsert();
     bean2.setId(e.getId());
     bean2.setName("stateless-update-name");
     bean2.setTitle(null);
 
-    Ebean.update(bean2);
+    DB.update(bean2);
 
     // title set on preUpdate
-    Assert.assertNotNull(bean2.getTitle());
+    assertNotNull(bean2.getTitle());
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/event/TestQueryAdapter.java b/ebean-test/src/test/java/org/tests/basic/event/TestQueryAdapter.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/basic/event/TestQueryAdapter.java
rename to ebean-test/src/test/java/org/tests/basic/event/TestQueryAdapter.java
index 425610c9f..f6050a161 100644
--- a/ebean-core/src/test/java/org/tests/basic/event/TestQueryAdapter.java
+++ b/ebean-test/src/test/java/org/tests/basic/event/TestQueryAdapter.java
@@ -1,11 +1,11 @@
 package org.tests.basic.event;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.QueryType;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.ResetBasicData;
 import org.tests.model.basic.TOne;
 
@@ -23,33 +23,33 @@ public class TestQueryAdapter extends BaseTestCase {
     TOne o = new TOne();
     o.setName("something");
 
-    Ebean.save(o);
+    DB.save(o);
 
-    Query<TOne> queryFindId = Ebean.find(TOne.class).setId(o.getId());
+    Query<TOne> queryFindId = DB.find(TOne.class).setId(o.getId());
 
     TOne one = queryFindId.findOne();
 
     assertThat(one.getId()).isEqualTo(o.getId());
     assertThat(sqlOf(queryFindId)).contains(" 1=1");
 
-    Query<TOne> notUsedQuery = Ebean.find(TOne.class);
+    Query<TOne> notUsedQuery = DB.find(TOne.class);
     assertThat(notUsedQuery.getQueryType()).isEqualTo(QueryType.FIND);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.update(TOne.class)
+    DB.update(TOne.class)
       .set("name", "mod")
       .where().idEq(o.getId())
       .update();
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertSql(sql.get(0)).contains(" 2=2");
 
-    Ebean.find(TOne.class)
+    DB.find(TOne.class)
       .where().idEq(o.getId())
       .delete();
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains(" 3=3");
 
   }
diff --git a/ebean-core/src/test/java/org/tests/basic/join/TestSecondaryJoin.java b/ebean-test/src/test/java/org/tests/basic/join/TestSecondaryJoin.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/basic/join/TestSecondaryJoin.java
rename to ebean-test/src/test/java/org/tests/basic/join/TestSecondaryJoin.java
index b218b6168..01da50bbe 100644
--- a/ebean-core/src/test/java/org/tests/basic/join/TestSecondaryJoin.java
+++ b/ebean-test/src/test/java/org/tests/basic/join/TestSecondaryJoin.java
@@ -1,12 +1,11 @@
 package org.tests.basic.join;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.TransactionalTestCase;
-
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.Order.Status;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -17,7 +16,7 @@ public class TestSecondaryJoin extends TransactionalTestCase {
 
     ResetBasicData.reset();
 
-    List<Order> list = Ebean.find(Order.class)
+    List<Order> list = DB.find(Order.class)
       // .select("*")
       // .join("customer")
       .findList();
@@ -26,7 +25,7 @@ public class TestSecondaryJoin extends TransactionalTestCase {
     o0.setCustomerName("Banan");
     o0.setStatus(Status.APPROVED);
 
-    Ebean.save(o0);
+    DB.save(o0);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/lob/TestBasicClobFetchEager.java b/ebean-test/src/test/java/org/tests/basic/lob/TestBasicClobFetchEager.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/basic/lob/TestBasicClobFetchEager.java
rename to ebean-test/src/test/java/org/tests/basic/lob/TestBasicClobFetchEager.java
index 831ec4ee5..9068b760a 100644
--- a/ebean-core/src/test/java/org/tests/basic/lob/TestBasicClobFetchEager.java
+++ b/ebean-test/src/test/java/org/tests/basic/lob/TestBasicClobFetchEager.java
@@ -1,17 +1,17 @@
 package org.tests.basic.lob;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.Query;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicClobFetchEager;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestBasicClobFetchEager extends BaseTestCase {
 
@@ -21,33 +21,33 @@ public class TestBasicClobFetchEager extends BaseTestCase {
     EBasicClobFetchEager entity = new EBasicClobFetchEager();
     entity.setName("test");
     entity.setDescription("initialClobValue");
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
     server.save(entity);
 
 
     String expectedSql = "select t0.id, t0.name, t0.title, t0.description, t0.last_update from ebasic_clob_fetch_eager t0 where t0.id = ?";
 
     // Clob included in fetch as FetchType.EAGER set by annotation
-    Query<EBasicClobFetchEager> defaultQuery = Ebean.find(EBasicClobFetchEager.class).setId(entity.getId());
+    Query<EBasicClobFetchEager> defaultQuery = DB.find(EBasicClobFetchEager.class).setId(entity.getId());
     defaultQuery.findOne();
     String sql = trimSql(defaultQuery.getGeneratedSql(), 6);
 
     assertThat(sql).contains(expectedSql);
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // Same as previous query - clob included by default based on annotation
-    Ebean.find(EBasicClobFetchEager.class, entity.getId());
+    DB.find(EBasicClobFetchEager.class, entity.getId());
 
     // Assert query same as previous ...
-    List<String> loggedSql = LoggedSqlCollector.stop();
-    Assert.assertEquals(1, loggedSql.size());
+    List<String> loggedSql = LoggedSql.stop();
+    assertEquals(1, loggedSql.size());
     assertThat(trimSql(loggedSql.get(0), 6)).contains(expectedSql);
 
 
     // Explicitly select * including Clob
-    Query<EBasicClobFetchEager> explicitQuery = Ebean.find(EBasicClobFetchEager.class).setId(entity.getId()).select("*");
+    Query<EBasicClobFetchEager> explicitQuery = DB.find(EBasicClobFetchEager.class).setId(entity.getId()).select("*");
 
     explicitQuery.findOne();
     sql = sqlOf(explicitQuery, 6);
@@ -59,23 +59,23 @@ public class TestBasicClobFetchEager extends BaseTestCase {
     EBasicClobFetchEager updateBean = new EBasicClobFetchEager();
     updateBean.setId(entity.getId());
     updateBean.setDescription("modified");
-    Ebean.update(updateBean);
+    DB.update(updateBean);
 
 
     // Test refresh function
 
-    Assert.assertEquals("initialClobValue", entity.getDescription());
+    assertEquals("initialClobValue", entity.getDescription());
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // Refresh query includes all properties
     server.refresh(entity);
 
     // Assert all properties fetched in refresh
-    loggedSql = LoggedSqlCollector.stop();
-    Assert.assertEquals(1, loggedSql.size());
+    loggedSql = LoggedSql.stop();
+    assertEquals(1, loggedSql.size());
     assertThat(trimSql(loggedSql.get(0), 6)).contains(expectedSql);
-    Assert.assertEquals("modified", entity.getDescription());
+    assertEquals("modified", entity.getDescription());
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/basic/lob/TestBasicClobNoVer.java b/ebean-test/src/test/java/org/tests/basic/lob/TestBasicClobNoVer.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/basic/lob/TestBasicClobNoVer.java
rename to ebean-test/src/test/java/org/tests/basic/lob/TestBasicClobNoVer.java
index f33a42a42..7289a7ac2 100644
--- a/ebean-core/src/test/java/org/tests/basic/lob/TestBasicClobNoVer.java
+++ b/ebean-test/src/test/java/org/tests/basic/lob/TestBasicClobNoVer.java
@@ -3,9 +3,9 @@ package org.tests.basic.lob;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicClobNoVer;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -53,13 +53,13 @@ public class TestBasicClobNoVer extends BaseTestCase {
 
     assertThat(entity.getDescription()).isEqualTo("initialClobValue");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // Refresh query includes all properties
     DB.refresh(entity);
 
     // Assert all properties fetched in refresh
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(trimSql(loggedSql.get(0), 2)).contains(sqlWithClob);
     assertThat(entity.getDescription()).isEqualTo("modified");
diff --git a/ebean-core/src/test/java/org/tests/basic/lob/TestByteOnly.java b/ebean-test/src/test/java/org/tests/basic/lob/TestByteOnly.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/basic/lob/TestByteOnly.java
rename to ebean-test/src/test/java/org/tests/basic/lob/TestByteOnly.java
index d675cb6b7..092924ed1 100644
--- a/ebean-core/src/test/java/org/tests/basic/lob/TestByteOnly.java
+++ b/ebean-test/src/test/java/org/tests/basic/lob/TestByteOnly.java
@@ -1,9 +1,9 @@
 package org.tests.basic.lob;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TBytesOnly;
-import org.junit.Test;
 
 public class TestByteOnly extends BaseTestCase {
 
@@ -14,14 +14,14 @@ public class TestByteOnly extends BaseTestCase {
     TBytesOnly e = new TBytesOnly();
     e.setContent(content);
 
-    Ebean.save(e);
+    DB.save(e);
 
     byte[] content2 = new byte[]{1, 1};
 
-    TBytesOnly e2 = Ebean.find(TBytesOnly.class, e.getId());
+    TBytesOnly e2 = DB.find(TBytesOnly.class, e.getId());
     e2.setContent(content2);
 
-    Ebean.save(e2);
+    DB.save(e2);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/one2one/Booking.java b/ebean-test/src/test/java/org/tests/basic/one2one/Booking.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/basic/one2one/Booking.java
rename to ebean-test/src/test/java/org/tests/basic/one2one/Booking.java
index 20a6c468e..fb5369233 100644
--- a/ebean-core/src/test/java/org/tests/basic/one2one/Booking.java
+++ b/ebean-test/src/test/java/org/tests/basic/one2one/Booking.java
@@ -1,16 +1,6 @@
 package org.tests.basic.one2one;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.OneToMany;
-import javax.persistence.OneToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/basic/one2one/Invoice.java b/ebean-test/src/test/java/org/tests/basic/one2one/Invoice.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/basic/one2one/Invoice.java
rename to ebean-test/src/test/java/org/tests/basic/one2one/Invoice.java
index 631863de5..7687f56d8 100644
--- a/ebean-core/src/test/java/org/tests/basic/one2one/Invoice.java
+++ b/ebean-test/src/test/java/org/tests/basic/one2one/Invoice.java
@@ -1,14 +1,6 @@
 package org.tests.basic.one2one;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "drel_invoice")
diff --git a/ebean-core/src/test/java/org/tests/basic/one2one/TestOne2OneBookingInvoice.java b/ebean-test/src/test/java/org/tests/basic/one2one/TestOne2OneBookingInvoice.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/basic/one2one/TestOne2OneBookingInvoice.java
rename to ebean-test/src/test/java/org/tests/basic/one2one/TestOne2OneBookingInvoice.java
index 48ad933cf..ab4f0c4ba 100644
--- a/ebean-core/src/test/java/org/tests/basic/one2one/TestOne2OneBookingInvoice.java
+++ b/ebean-test/src/test/java/org/tests/basic/one2one/TestOne2OneBookingInvoice.java
@@ -1,12 +1,10 @@
 package org.tests.basic.one2one;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestOne2OneBookingInvoice extends BaseTestCase {
 
@@ -23,12 +21,12 @@ public class TestOne2OneBookingInvoice extends BaseTestCase {
     b.setAgentInvoice(ai);
     b.setClientInvoice(ci);
 
-    Ebean.save(b);
+    DB.save(b);
 
-    Invoice invoice = Ebean.find(Invoice.class, ai.getId());
+    Invoice invoice = DB.find(Invoice.class, ai.getId());
     assertEquals(b.getId(), invoice.getBooking().getId());
 
-    Booking b1 = Ebean.find(Booking.class, b.getId());
+    Booking b1 = DB.find(Booking.class, b.getId());
 
     Invoice ai1 = b1.getAgentInvoice();
     assertNotNull(ai1);
@@ -47,8 +45,8 @@ public class TestOne2OneBookingInvoice extends BaseTestCase {
     // cleanup
     ai.setBooking(null);
     ci.setBooking(null);
-    Ebean.save(ai);
-    Ebean.save(ci);
-    Ebean.delete(b);
+    DB.save(ai);
+    DB.save(ci);
+    DB.delete(b);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/one2one/TestOneToOneWheelTire.java b/ebean-test/src/test/java/org/tests/basic/one2one/TestOneToOneWheelTire.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/basic/one2one/TestOneToOneWheelTire.java
rename to ebean-test/src/test/java/org/tests/basic/one2one/TestOneToOneWheelTire.java
index 6203d3071..2ec4a3d96 100644
--- a/ebean-core/src/test/java/org/tests/basic/one2one/TestOneToOneWheelTire.java
+++ b/ebean-test/src/test/java/org/tests/basic/one2one/TestOneToOneWheelTire.java
@@ -1,8 +1,8 @@
 package org.tests.basic.one2one;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 public class TestOneToOneWheelTire extends BaseTestCase {
 
@@ -14,9 +14,9 @@ public class TestOneToOneWheelTire extends BaseTestCase {
     t.setWheel(w);
     w.setTire(t);
 
-    Ebean.save(t);
+    DB.save(t);
 
-    Ebean.delete(t);
+    DB.delete(t);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/one2one/Tire.java b/ebean-test/src/test/java/org/tests/basic/one2one/Tire.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/basic/one2one/Tire.java
rename to ebean-test/src/test/java/org/tests/basic/one2one/Tire.java
index 98ded2763..a26f18257 100644
--- a/ebean-core/src/test/java/org/tests/basic/one2one/Tire.java
+++ b/ebean-test/src/test/java/org/tests/basic/one2one/Tire.java
@@ -1,14 +1,6 @@
 package org.tests.basic.one2one;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.OneToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "tire")
diff --git a/ebean-core/src/test/java/org/tests/basic/one2one/Wheel.java b/ebean-test/src/test/java/org/tests/basic/one2one/Wheel.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/basic/one2one/Wheel.java
rename to ebean-test/src/test/java/org/tests/basic/one2one/Wheel.java
index 2f07043dc..01b617d0d 100644
--- a/ebean-core/src/test/java/org/tests/basic/one2one/Wheel.java
+++ b/ebean-test/src/test/java/org/tests/basic/one2one/Wheel.java
@@ -1,13 +1,6 @@
 package org.tests.basic.one2one;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "wheel")
diff --git a/ebean-core/src/test/java/org/tests/basic/type/BSimpleWithGen.java b/ebean-test/src/test/java/org/tests/basic/type/BSimpleWithGen.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/basic/type/BSimpleWithGen.java
rename to ebean-test/src/test/java/org/tests/basic/type/BSimpleWithGen.java
diff --git a/ebean-core/src/test/java/org/tests/basic/type/TestEnumValueAnnotation.java b/ebean-test/src/test/java/org/tests/basic/type/TestEnumValueAnnotation.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/basic/type/TestEnumValueAnnotation.java
rename to ebean-test/src/test/java/org/tests/basic/type/TestEnumValueAnnotation.java
index e7b8577cb..0ebacbde6 100644
--- a/ebean-core/src/test/java/org/tests/basic/type/TestEnumValueAnnotation.java
+++ b/ebean-test/src/test/java/org/tests/basic/type/TestEnumValueAnnotation.java
@@ -4,8 +4,7 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.SqlQuery;
 import io.ebean.SqlRow;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
 import org.tests.model.basic.EBasic.Status;
 import org.tests.model.basic.EBasicEnumId;
@@ -13,8 +12,9 @@ import org.tests.model.basic.EBasicEnumInt;
 
 import java.util.Optional;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestEnumValueAnnotation extends BaseTestCase {
 
@@ -65,7 +65,7 @@ public class TestEnumValueAnnotation extends BaseTestCase {
     try {
       b = DB.find(EBasicEnumId.class, b.getStatus());
     } catch (java.lang.IllegalArgumentException iae) {
-      Assert.fail("The use of an enum as id should work : " + iae.getLocalizedMessage());
+      fail("The use of an enum as id should work : " + iae.getLocalizedMessage());
     }
 
     assertEquals(EBasicEnumId.Status.NEW, b.getStatus());
diff --git a/ebean-core/src/test/java/org/tests/basic/type/TestExtraScalarTypes.java b/ebean-test/src/test/java/org/tests/basic/type/TestExtraScalarTypes.java
similarity index 62%
rename from ebean-core/src/test/java/org/tests/basic/type/TestExtraScalarTypes.java
rename to ebean-test/src/test/java/org/tests/basic/type/TestExtraScalarTypes.java
index 2d68014c7..133adada4 100644
--- a/ebean-core/src/test/java/org/tests/basic/type/TestExtraScalarTypes.java
+++ b/ebean-test/src/test/java/org/tests/basic/type/TestExtraScalarTypes.java
@@ -1,17 +1,17 @@
 package org.tests.basic.type;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.ESomeType;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.Currency;
 import java.util.List;
 import java.util.Locale;
 import java.util.TimeZone;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestExtraScalarTypes extends BaseTestCase {
 
@@ -27,15 +27,15 @@ public class TestExtraScalarTypes extends BaseTestCase {
     e.setTimeZone(tz);
     e.setCurrency(currency);
 
-    Ebean.save(e);
+    DB.save(e);
 
-    ESomeType e2 = Ebean.find(ESomeType.class).setAutoTune(false).setId(e.getId()).findOne();
+    ESomeType e2 = DB.find(ESomeType.class).setAutoTune(false).setId(e.getId()).findOne();
 
-    Assert.assertNotNull(e2.getCurrency());
-    Assert.assertNotNull(e2.getLocale());
-    Assert.assertNotNull(e2.getTimeZone());
+    assertNotNull(e2.getCurrency());
+    assertNotNull(e2.getLocale());
+    assertNotNull(e2.getTimeZone());
 
-    List<ESomeType> list = Ebean.find(ESomeType.class)
+    List<ESomeType> list = DB.find(ESomeType.class)
       .setAutoTune(false).where()
       .eq("locale", locale)
       .eq("timeZone", tz.getID())
diff --git a/ebean-core/src/test/java/org/tests/basic/type/TestInetAddressType.java b/ebean-test/src/test/java/org/tests/basic/type/TestInetAddressType.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/basic/type/TestInetAddressType.java
rename to ebean-test/src/test/java/org/tests/basic/type/TestInetAddressType.java
index 66910df8f..ec226169b 100644
--- a/ebean-core/src/test/java/org/tests/basic/type/TestInetAddressType.java
+++ b/ebean-test/src/test/java/org/tests/basic/type/TestInetAddressType.java
@@ -4,7 +4,7 @@ import io.ebean.DB;
 import io.ebean.TransactionalTestCase;
 import io.ebean.types.Cidr;
 import io.ebean.types.Inet;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EWithInetAddr;
 
 import java.net.InetAddress;
@@ -13,8 +13,8 @@ import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestInetAddressType extends TransactionalTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/basic/type/TestQueryBooleanProperty.java b/ebean-test/src/test/java/org/tests/basic/type/TestQueryBooleanProperty.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/basic/type/TestQueryBooleanProperty.java
rename to ebean-test/src/test/java/org/tests/basic/type/TestQueryBooleanProperty.java
index 043150526..5229806e5 100644
--- a/ebean-core/src/test/java/org/tests/basic/type/TestQueryBooleanProperty.java
+++ b/ebean-test/src/test/java/org/tests/basic/type/TestQueryBooleanProperty.java
@@ -1,9 +1,9 @@
 package org.tests.basic.type;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TOne;
-import org.junit.Test;
 
 public class TestQueryBooleanProperty extends BaseTestCase {
 
@@ -11,6 +11,6 @@ public class TestQueryBooleanProperty extends BaseTestCase {
   public void test() {
 
     // when run in MySql is test for BUG 323
-    Ebean.find(TOne.class).where().eq("active", true).findList();
+    DB.find(TOne.class).where().eq("active", true).findList();
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/basic/type/TestSqlRowUUID.java b/ebean-test/src/test/java/org/tests/basic/type/TestSqlRowUUID.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/basic/type/TestSqlRowUUID.java
rename to ebean-test/src/test/java/org/tests/basic/type/TestSqlRowUUID.java
index 77b67724a..d2b3084f3 100644
--- a/ebean-core/src/test/java/org/tests/basic/type/TestSqlRowUUID.java
+++ b/ebean-test/src/test/java/org/tests/basic/type/TestSqlRowUUID.java
@@ -4,7 +4,7 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.SqlQuery;
 import io.ebean.SqlRow;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TUuidEntity;
 
 import java.util.Arrays;
@@ -12,8 +12,8 @@ import java.util.List;
 import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestSqlRowUUID extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/basic/type/TestTransientMap.java b/ebean-test/src/test/java/org/tests/basic/type/TestTransientMap.java
similarity index 95%
rename from ebean-core/src/test/java/org/tests/basic/type/TestTransientMap.java
rename to ebean-test/src/test/java/org/tests/basic/type/TestTransientMap.java
index cb6f7b8c1..7ee4ca9a9 100644
--- a/ebean-core/src/test/java/org/tests/basic/type/TestTransientMap.java
+++ b/ebean-test/src/test/java/org/tests/basic/type/TestTransientMap.java
@@ -2,7 +2,7 @@ package org.tests.basic.type;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.HashMap;
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertFlush.java b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertFlush.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertFlush.java
rename to ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertFlush.java
index 2f9cdf7f1..65b7b8005 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertFlush.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertFlush.java
@@ -1,20 +1,15 @@
 package org.tests.batchinsert;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.DtoQuery2Test;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import io.ebean.Transaction;
+import io.ebean.*;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.annotation.Platform;
 import io.ebean.annotation.Transactional;
 import io.ebean.meta.MetaTimedMetric;
 import io.ebean.meta.ServerMetrics;
+import io.ebean.test.LoggedSql;
 import io.ebeaninternal.api.SpiTransaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasicVer;
 import org.tests.model.basic.TSDetail;
@@ -24,14 +19,14 @@ import java.sql.Timestamp;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestBatchInsertFlush extends BaseTestCase {
 
   @Test
   public void no_cascade() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     resetAllMetrics();
 
@@ -42,7 +37,7 @@ public class TestBatchInsertFlush extends BaseTestCase {
       transaction.setBatchMode(true);
       transaction.setLabel("TestBatchInsertFlush.no_cascade");
 
-      LoggedSqlCollector.start();
+      LoggedSql.start();
 
       TSMaster m = new TSMaster();
       m.setName("master1");
@@ -65,7 +60,7 @@ public class TestBatchInsertFlush extends BaseTestCase {
 
       transaction.commit();
 
-      List<String> sql = LoggedSqlCollector.stop();
+      List<String> sql = LoggedSql.stop();
 
       // we get the 2 master inserts first
       assertSql(sql.get(0)).contains("insert into t_atable_thatisrelatively");
@@ -95,15 +90,15 @@ public class TestBatchInsertFlush extends BaseTestCase {
   @Transactional(batch = PersistBatch.ALL, flushOnQuery = false)
   public void transactional_flushOnQueryFalse() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.save(new EBasicVer("b1"));
-    Ebean.save(new EBasicVer("b2"));
+    DB.save(new EBasicVer("b1"));
+    DB.save(new EBasicVer("b2"));
 
     // does not trigger JDBC batch with flushOnQuery = false
-    Ebean.find(Customer.class).findCount();
+    DB.find(Customer.class).findCount();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select count(*)");
   }
 
@@ -111,7 +106,7 @@ public class TestBatchInsertFlush extends BaseTestCase {
   @Transactional(batchSize = 20)
   public void transactional_flushOnSqlQuery() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.save(new EBasicVer("b1"));
     DB.save(new EBasicVer("b2"));
@@ -121,7 +116,7 @@ public class TestBatchInsertFlush extends BaseTestCase {
       .mapToScalar(Integer.class)
       .findOne();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("insert into e_basicver");
   }
 
@@ -129,7 +124,7 @@ public class TestBatchInsertFlush extends BaseTestCase {
   @Transactional(batchSize = 20)
   public void transactional_flushOnDtoQuery() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.save(new EBasicVer("b1"));
     DB.save(new EBasicVer("b2"));
@@ -138,7 +133,7 @@ public class TestBatchInsertFlush extends BaseTestCase {
     DB.findDto(DtoQuery2Test.DCust.class, "select id, name from o_customer")
     .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("insert into e_basicver");
   }
 
@@ -146,15 +141,15 @@ public class TestBatchInsertFlush extends BaseTestCase {
   @Transactional(batch = PersistBatch.ALL)
   public void transactional_flushOnQuery() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.save(new EBasicVer("b1"));
-    Ebean.save(new EBasicVer("b2"));
+    DB.save(new EBasicVer("b1"));
+    DB.save(new EBasicVer("b2"));
 
     // by default triggers flush of JDBC batch
-    Ebean.find(Customer.class).findCount();
+    DB.find(Customer.class).findCount();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("insert into e_basicver");
   }
 
@@ -163,8 +158,8 @@ public class TestBatchInsertFlush extends BaseTestCase {
   @IgnorePlatform({Platform.SQLSERVER, Platform.HANA}) // has generated IDs
   public void transactional_flushOnGetId() {
 
-    EbeanServer server = Ebean.getDefaultServer();
-    LoggedSqlCollector.start();
+    Database server = DB.getDefault();
+    LoggedSql.start();
 
     EBasicVer b1 = new EBasicVer("b1");
     server.save(b1);
@@ -173,10 +168,10 @@ public class TestBatchInsertFlush extends BaseTestCase {
     server.save(b2);
 
     //flush here
-    assertThat(LoggedSqlCollector.current()).isEmpty();
+    assertThat(LoggedSql.collect()).isEmpty();
     Integer id = b1.getId();
     assertNotNull(id);
-    assertThat(LoggedSqlCollector.current()).hasSize(3);
+    assertThat(LoggedSql.collect()).hasSize(3);
 
     EBasicVer b3 = new EBasicVer("b3");
     server.save(b3);
@@ -186,10 +181,10 @@ public class TestBatchInsertFlush extends BaseTestCase {
   @IgnorePlatform({Platform.SQLSERVER, Platform.HANA})
   public void testFlushOnGetId() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     Transaction txn = server.beginTransaction();
     try {
-      LoggedSqlCollector.start();
+      LoggedSql.start();
       txn.setBatchMode(true);
 
       EBasicVer b1 = new EBasicVer("b1");
@@ -199,10 +194,10 @@ public class TestBatchInsertFlush extends BaseTestCase {
       server.save(b2, txn);
 
       //flush here
-      assertThat(LoggedSqlCollector.current()).isEmpty();
+      assertThat(LoggedSql.collect()).isEmpty();
       Integer id = b1.getId();
       assertNotNull(id);
-      assertThat(LoggedSqlCollector.current()).hasSize(3);
+      assertThat(LoggedSql.collect()).hasSize(3);
 
       EBasicVer b3 = new EBasicVer("b3");
       server.save(b3, txn);
@@ -218,9 +213,9 @@ public class TestBatchInsertFlush extends BaseTestCase {
   @Transactional(batch = PersistBatch.ALL)
   public void transactional_noflushWhenIdIsLoaded() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     EBasicVer b1 = new EBasicVer("b1");
     b1.setId(78965);
@@ -230,11 +225,11 @@ public class TestBatchInsertFlush extends BaseTestCase {
     b2.setId(78645);
     server.save(b2);
 
-    assertThat(LoggedSqlCollector.current()).isEmpty();
+    assertThat(LoggedSql.collect()).isEmpty();
     // dont flush here
     Integer id = b1.getId();
     assertNotNull(id);
-    assertThat(LoggedSqlCollector.current()).isEmpty();
+    assertThat(LoggedSql.collect()).isEmpty();
 
     EBasicVer b3 = new EBasicVer("b3");
     server.save(b3);
@@ -245,10 +240,10 @@ public class TestBatchInsertFlush extends BaseTestCase {
   @IgnorePlatform({Platform.SQLSERVER, Platform.ORACLE})
   public void noflushWhenIdIsLoaded() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     Transaction txn = server.beginTransaction();
     try {
-      LoggedSqlCollector.start();
+      LoggedSql.start();
       txn.setBatchMode(true);
 
       EBasicVer b1 = new EBasicVer("b1");
@@ -259,17 +254,17 @@ public class TestBatchInsertFlush extends BaseTestCase {
       b2.setId(21354);
       server.save(b2, txn);
 
-      assertThat(LoggedSqlCollector.current()).isEmpty();
+      assertThat(LoggedSql.collect()).isEmpty();
       //dont flush here
       Integer id = b1.getId();
       assertNotNull(id);
-      assertThat(LoggedSqlCollector.current()).isEmpty();
+      assertThat(LoggedSql.collect()).isEmpty();
 
       EBasicVer b3 = new EBasicVer("b3");
       server.save(b3, txn);
 
       txn.commit();
-      assertThat(LoggedSqlCollector.current()).hasSize(5);
+      assertThat(LoggedSql.collect()).hasSize(5);
 
     } finally {
       txn.end();
@@ -279,7 +274,7 @@ public class TestBatchInsertFlush extends BaseTestCase {
   @Test
   public void testFlushOnGetProperty() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     Transaction txn = server.beginTransaction();
     try {
       txn.setBatchMode(true);
@@ -307,7 +302,7 @@ public class TestBatchInsertFlush extends BaseTestCase {
   @Test
   public void testFlushOnSetProperty() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     Transaction txn = server.beginTransaction();
     try {
       txn.setBatchMode(true);
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertOneToOne.java b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertOneToOne.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertOneToOne.java
rename to ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertOneToOne.java
index 620b926bb..f20e9bf91 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertOneToOne.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertOneToOne.java
@@ -1,14 +1,10 @@
 package org.tests.batchinsert;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.annotation.Transactional;
-import org.junit.Test;
-import org.tests.batchinsert.o2o.MeterAddressData;
-import org.tests.batchinsert.o2o.MeterContractData;
-import org.tests.batchinsert.o2o.MeterSpecialNeedsClient;
-import org.tests.batchinsert.o2o.MeterSpecialNeedsContact;
-import org.tests.batchinsert.o2o.MeterVersion;
+import org.junit.jupiter.api.Test;
+import org.tests.batchinsert.o2o.*;
 
 public class TestBatchInsertOneToOne {
   private MeterVersion build(){
@@ -35,6 +31,6 @@ public class TestBatchInsertOneToOne {
   public void test() {
     MeterVersion meterVersion = build();
 
-    Ebean.save(meterVersion);
+    DB.save(meterVersion);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertSimple.java b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertSimple.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertSimple.java
rename to ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertSimple.java
index 376feef41..b8c041f5b 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertSimple.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertSimple.java
@@ -2,13 +2,12 @@ package org.tests.batchinsert;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.annotation.Platform;
 import io.ebean.annotation.Transactional;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UTDetail;
 import org.tests.model.basic.UTMaster;
 
@@ -17,7 +16,7 @@ import java.util.List;
 import java.util.Random;
 
 //import static org.assertj.core.api.Assertions.assertThat;
-//import static org.junit.Assert.assertNull;
+//import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestBatchInsertSimple extends BaseTestCase {
 
@@ -28,7 +27,7 @@ public class TestBatchInsertSimple extends BaseTestCase {
 
     int numOfMasters = 4;// 2 + random.nextInt(8);
 
-    Transaction transaction = Ebean.beginTransaction();
+    Transaction transaction = DB.beginTransaction();
     try {
       transaction.setBatchMode(false);
       transaction.setBatchOnCascade(true);
@@ -102,7 +101,7 @@ public class TestBatchInsertSimple extends BaseTestCase {
 
     int numOfMasters = 4;
 
-    Transaction transaction = Ebean.beginTransaction();
+    Transaction transaction = DB.beginTransaction();
     try {
       transaction.setBatchMode(false);
       transaction.setBatchOnCascade(true);
@@ -112,7 +111,7 @@ public class TestBatchInsertSimple extends BaseTestCase {
 
       for (int i = 0; i < numOfMasters; i++) {
         UTMaster master = createMaster(i);
-        Ebean.save(master);
+        DB.save(master);
       }
 
       transaction.commit();
@@ -132,14 +131,14 @@ public class TestBatchInsertSimple extends BaseTestCase {
       masters.add(createMasterAndDetails(i, 7));
     }
 
-    Transaction transaction = Ebean.beginTransaction();
+    Transaction transaction = DB.beginTransaction();
     try {
       transaction.setBatchMode(true);
-      transaction.setBatchOnCascade(PersistBatch.ALL.equals(spiEbeanServer().getDatabasePlatform().getPersistBatchOnCascade()));
+      transaction.setBatchOnCascade(PersistBatch.ALL.equals(spiEbeanServer().databasePlatform().getPersistBatchOnCascade()));
       transaction.setBatchSize(20);
 
       // escalate based on batchOnCascade value
-      Ebean.saveAll(masters);
+      DB.saveAll(masters);
 
       transaction.commit();
 
@@ -159,7 +158,7 @@ public class TestBatchInsertSimple extends BaseTestCase {
     }
 
     // escalate based on batchOnCascade value
-    Ebean.saveAll(masters);
+    DB.saveAll(masters);
 
     for (int i = 0; i < masters.size(); i++) {
       UTMaster utMaster = masters.get(i);
@@ -170,7 +169,7 @@ public class TestBatchInsertSimple extends BaseTestCase {
       }
     }
 
-    Ebean.saveAll(masters);
+    DB.saveAll(masters);
   }
 
   private UTMaster createMasterAndDetails(int masterPos, int size) {
@@ -209,7 +208,7 @@ public class TestBatchInsertSimple extends BaseTestCase {
     return detail;
   }
 
-  @Test(expected = Test.None.class)// no exception expected
+  @Test
   public void npe_addBatch_withoutAnyBindParams() {
     try (Transaction txn = DB.beginTransaction()) {
       // don't write code like this please ...
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertWithInitialisedCollection.java b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertWithInitialisedCollection.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertWithInitialisedCollection.java
rename to ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertWithInitialisedCollection.java
index 5a6fadfca..a4da626c3 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchInsertWithInitialisedCollection.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchInsertWithInitialisedCollection.java
@@ -1,10 +1,10 @@
 package org.tests.batchinsert;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.OCachedBean;
 
 import java.util.ArrayList;
@@ -26,20 +26,20 @@ public class TestBatchInsertWithInitialisedCollection extends BaseTestCase {
       list.add(bean);
     }
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Transaction txn = Ebean.beginTransaction();
+    Transaction txn = DB.beginTransaction();
     try {
       txn.setBatchMode(true);
 
-      Ebean.saveAll(list);
+      DB.saveAll(list);
       txn.commit();
 
     } finally {
       txn.end();
     }
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(4);
     assertThat(loggedSql.get(0)).contains("insert into o_cached_bean (");
     assertThat(loggedSql.get(0)).contains("name) values (?");
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchOnCascadeExceptionHandling.java b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchOnCascadeExceptionHandling.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/batchinsert/TestBatchOnCascadeExceptionHandling.java
rename to ebean-test/src/test/java/org/tests/batchinsert/TestBatchOnCascadeExceptionHandling.java
index a1a084dcb..cc41e4933 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchOnCascadeExceptionHandling.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchOnCascadeExceptionHandling.java
@@ -1,7 +1,7 @@
 package org.tests.batchinsert;
 
 import io.ebean.BaseTestCase;
-import io.ebean.EbeanServer;
+import io.ebean.Database;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.PersistBatch;
@@ -9,7 +9,7 @@ import io.ebean.annotation.Platform;
 import io.ebeaninternal.api.SpiTransaction;
 import io.ebeaninternal.server.persist.BatchControl;
 import org.assertj.core.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicWithUniqueCon;
 import org.tests.model.basic.EOptOneB;
 import org.tests.model.basic.EOptOneC;
@@ -30,12 +30,12 @@ public class TestBatchOnCascadeExceptionHandling extends BaseTestCase {
     Transaction txn = server().beginTransaction();
     try {
       EBasicWithUniqueCon v2 = createEntityWithName("conflict", "after");
-      txn.flushBatch();
-      Savepoint sp = txn.getConnection().setSavepoint();
+      txn.flush();
+      Savepoint sp = txn.connection().setSavepoint();
       try {
         server().save(v2); // unique key violation
       } catch (PersistenceException e) {
-        txn.getConnection().rollback(sp);
+        txn.connection().rollback(sp);
 
         EBasicWithUniqueCon conflicting = server().find(EBasicWithUniqueCon.class).where().eq("name", "conflict").findOne();
         assertThat(conflicting).isNotNull();
@@ -86,11 +86,11 @@ public class TestBatchOnCascadeExceptionHandling extends BaseTestCase {
     });
   }
 
-  protected void testBatchOnCascadeIsExceptionSafe(EbeanServer server, Runnable failingOperation) {
+  protected void testBatchOnCascadeIsExceptionSafe(Database server, Runnable failingOperation) {
     Transaction txn = server.beginTransaction();
     try {
       assertThat(txn.isBatchMode()).isFalse();
-      assertThat(txn.isBatchOnCascade()).isSameAs(PersistBatch.ALL.equals(spiEbeanServer().getDatabasePlatform().getPersistBatchOnCascade()));
+      assertThat(txn.isBatchOnCascade()).isSameAs(PersistBatch.ALL.equals(spiEbeanServer().databasePlatform().getPersistBatchOnCascade()));
 
       failingOperation.run();
       Assertions.fail("PersistenceException expected");
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchSaveWithGetBeanId.java b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchSaveWithGetBeanId.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/batchinsert/TestBatchSaveWithGetBeanId.java
rename to ebean-test/src/test/java/org/tests/batchinsert/TestBatchSaveWithGetBeanId.java
index a83aa13ae..7239731d5 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/TestBatchSaveWithGetBeanId.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/TestBatchSaveWithGetBeanId.java
@@ -1,15 +1,15 @@
 package org.tests.batchinsert;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.annotation.Transactional;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestBatchSaveWithGetBeanId extends BaseTestCase {
 
@@ -23,7 +23,7 @@ public class TestBatchSaveWithGetBeanId extends BaseTestCase {
   @IgnorePlatform(Platform.HANA) // HANA doesn't support insert batching
   public void test() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     Customer model = new Customer();
     model.setName("foo");
 
@@ -31,9 +31,9 @@ public class TestBatchSaveWithGetBeanId extends BaseTestCase {
 
     // should invoke a flush which then means the
     // insert occurs and the bean has an Id value
-    Object beanId = server.getBeanId(model);
+    Object beanId = server.beanId(model);
     assertNotNull(beanId);
 
-    Ebean.delete(Customer.class, beanId);
+    DB.delete(Customer.class, beanId);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterAddressData.java b/ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterAddressData.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterAddressData.java
rename to ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterAddressData.java
index d91cc475e..9357a2668 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterAddressData.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterAddressData.java
@@ -1,9 +1,10 @@
 package org.tests.batchinsert.o2o;
 
 import io.ebean.annotation.NotNull;
-import java.util.UUID;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
+import java.util.UUID;
 
 @Entity
 public class MeterAddressData {
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterContractData.java b/ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterContractData.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterContractData.java
rename to ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterContractData.java
index 537dc411b..f4112c746 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterContractData.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterContractData.java
@@ -1,11 +1,12 @@
 package org.tests.batchinsert.o2o;
 
 import io.ebean.annotation.NotNull;
-import java.util.UUID;
+
 import javax.persistence.CascadeType;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.OneToOne;
+import java.util.UUID;
 
 @Entity
 public class MeterContractData {
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsClient.java b/ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsClient.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsClient.java
rename to ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsClient.java
index d042b5dff..c2c6375c2 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsClient.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsClient.java
@@ -1,10 +1,10 @@
 package org.tests.batchinsert.o2o;
 
-import java.util.UUID;
 import javax.persistence.CascadeType;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.OneToOne;
+import java.util.UUID;
 
 @Entity
 public class MeterSpecialNeedsClient {
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsContact.java b/ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsContact.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsContact.java
rename to ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsContact.java
index 029868433..e75f24aeb 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsContact.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterSpecialNeedsContact.java
@@ -1,8 +1,8 @@
 package org.tests.batchinsert.o2o;
 
-import java.util.UUID;
 import javax.persistence.Entity;
 import javax.persistence.Id;
+import java.util.UUID;
 
 @Entity
 public class MeterSpecialNeedsContact {
diff --git a/ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterVersion.java b/ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterVersion.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterVersion.java
rename to ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterVersion.java
index 49ce21860..8339ca353 100644
--- a/ebean-core/src/test/java/org/tests/batchinsert/o2o/MeterVersion.java
+++ b/ebean-test/src/test/java/org/tests/batchinsert/o2o/MeterVersion.java
@@ -1,11 +1,12 @@
 package org.tests.batchinsert.o2o;
 
 import io.ebean.annotation.NotNull;
-import java.util.UUID;
+
 import javax.persistence.CascadeType;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.OneToOne;
+import java.util.UUID;
 
 @Entity
 public class MeterVersion {
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestBasicLazy.java b/ebean-test/src/test/java/org/tests/batchload/TestBasicLazy.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/batchload/TestBasicLazy.java
rename to ebean-test/src/test/java/org/tests/batchload/TestBasicLazy.java
index 9656832a1..dfca84655 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestBasicLazy.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestBasicLazy.java
@@ -1,24 +1,20 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Expr;
-import io.ebean.FetchConfig;
 import io.ebean.Transaction;
+import org.junit.jupiter.api.Test;
 import org.tests.basic.MyTestDataSourcePoolListener;
-import org.tests.model.basic.Address;
-import org.tests.model.basic.Contact;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
+import org.tests.model.basic.*;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestBasicLazy extends BaseTestCase {
 
   @Test
@@ -26,18 +22,18 @@ public class TestBasicLazy extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Order order = Ebean.find(Order.class).select("totalAmount").setMaxRows(1).order("id")
+    Order order = DB.find(Order.class).select("totalAmount").setMaxRows(1).order("id")
       .findOne();
 
-    Assert.assertNotNull(order);
+    assertNotNull(order);
 
     Customer customer = order.getCustomer();
-    Assert.assertNotNull(customer);
-    Assert.assertNotNull(customer.getName());
+    assertNotNull(customer);
+    assertNotNull(customer.getName());
 
     Address address = customer.getBillingAddress();
-    Assert.assertNotNull(address);
-    Assert.assertNotNull(address.getCity());
+    assertNotNull(address);
+    assertNotNull(address.getCity());
   }
 
   public void test_N1N() {
@@ -45,27 +41,27 @@ public class TestBasicLazy extends BaseTestCase {
 
     // safety check to see if our customer we are going to use for the test has
     // some contacts
-    Customer c = Ebean.find(Customer.class).setId(1).findOne();
-    Assert.assertNotNull(c.getContacts());
-    Assert.assertTrue("no contacts on test customer 1", !c.getContacts().isEmpty());
+    Customer c = DB.find(Customer.class).setId(1).findOne();
+    assertNotNull(c.getContacts());
+    assertTrue(!c.getContacts().isEmpty());
 
     // start transaction so we have a "long running" persistence context
-    Transaction tx = Ebean.beginTransaction();
+    Transaction tx = DB.beginTransaction();
     try {
-      List<Order> order = Ebean.find(Order.class).where(Expr.eq("customer.id", 1)).findList();
+      List<Order> order = DB.find(Order.class).where(Expr.eq("customer.id", 1)).findList();
 
-      Assert.assertNotNull(order);
-      Assert.assertTrue(!order.isEmpty());
+      assertNotNull(order);
+      assertTrue(!order.isEmpty());
 
       Customer customer = order.get(0).getCustomer();
-      Assert.assertNotNull(customer);
-      Assert.assertEquals(1, customer.getId().intValue());
+      assertNotNull(customer);
+      assertEquals(1, customer.getId().intValue());
 
       // this should lazily fetch the contacts
       List<Contact> contacts = customer.getContacts();
 
-      Assert.assertNotNull(contacts);
-      Assert.assertTrue("contacts not lazily fetched", !contacts.isEmpty());
+      assertNotNull(contacts);
+      assertTrue(!contacts.isEmpty());
     } finally {
       tx.commit();
     }
@@ -74,22 +70,22 @@ public class TestBasicLazy extends BaseTestCase {
   public void testRaceCondition_Simple() throws Throwable {
     ResetBasicData.reset();
 
-    Order order = Ebean.find(Order.class).select("totalAmount").setMaxRows(1).order("id")
+    Order order = DB.find(Order.class).select("totalAmount").setMaxRows(1).order("id")
       .findOne();
 
-    Assert.assertNotNull(order);
+    assertNotNull(order);
 
     final Customer customer = order.getCustomer();
-    Assert.assertNotNull(customer);
+    assertNotNull(customer);
 
-    Assert.assertTrue(Ebean.getBeanState(customer).isReference());
+    assertTrue(DB.beanState(customer).isReference());
 
     final Throwable throwables[] = new Throwable[2];
     Thread t1 = new Thread() {
       @Override
       public void run() {
         try {
-          Assert.assertNotNull(customer.getName());
+          assertNotNull(customer.getName());
         } catch (Throwable e) {
           throwables[0] = e;
         }
@@ -100,7 +96,7 @@ public class TestBasicLazy extends BaseTestCase {
       @Override
       public void run() {
         try {
-          Assert.assertNotNull(customer.getName());
+          assertNotNull(customer.getName());
         } catch (Throwable e) {
           throwables[1] = e;
         }
@@ -119,7 +115,7 @@ public class TestBasicLazy extends BaseTestCase {
       MyTestDataSourcePoolListener.SLEEP_AFTER_BORROW = 0;
     }
 
-    Assert.assertFalse(Ebean.getBeanState(customer).isReference());
+    assertFalse(DB.beanState(customer).isReference());
 
     if (throwables[0] != null) {
       throw throwables[0];
@@ -177,8 +173,8 @@ public class TestBasicLazy extends BaseTestCase {
     new FetchThread(tg, 2).start();
     new FetchThread(tg, 3).start();
 
-    orders = Ebean.find(Order.class).fetchLazy("customer").findList();
-    Assert.assertTrue(orders.size() >= 4);
+    orders = DB.find(Order.class).fetchLazy("customer").findList();
+    assertTrue(orders.size() >= 4);
 
     try {
       MyTestDataSourcePoolListener.SLEEP_AFTER_BORROW = 2000;
@@ -200,7 +196,7 @@ public class TestBasicLazy extends BaseTestCase {
       for (Throwable exception : exceptions) {
         exception.printStackTrace();
       }
-      Assert.fail();
+      fail();
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestBasicNavOnEmpty.java b/ebean-test/src/test/java/org/tests/batchload/TestBasicNavOnEmpty.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/batchload/TestBasicNavOnEmpty.java
rename to ebean-test/src/test/java/org/tests/batchload/TestBasicNavOnEmpty.java
index 5354c7cf3..f017ae3ee 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestBasicNavOnEmpty.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestBasicNavOnEmpty.java
@@ -1,15 +1,16 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestBasicNavOnEmpty extends BaseTestCase {
 
   @Test
@@ -20,15 +21,15 @@ public class TestBasicNavOnEmpty extends BaseTestCase {
     Customer c = new Customer();
     c.setName("HelloRob");
 
-    Ebean.save(c);
+    DB.save(c);
 
-    c = Ebean.find(Customer.class, c.getId());
+    c = DB.find(Customer.class, c.getId());
 
     List<Contact> contacts = c.getContacts();
-    Assert.assertEquals(0, contacts.size());
+    assertEquals(0, contacts.size());
 
     // cleanup
-    Ebean.delete(c);
+    DB.delete(c);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java b/ebean-test/src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java
similarity index 51%
rename from ebean-core/src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java
rename to ebean-test/src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java
index d6066f66e..879fb1097 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java
@@ -1,97 +1,83 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheStatistics;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UUOne;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestBatchLazyWithCacheHits extends BaseTestCase {
 
-  private ServerCache beanCache = server().getServerCacheManager().getBeanCache(UUOne.class);
+  private final ServerCache beanCache = server().cacheManager().beanCache(UUOne.class);
 
   private UUOne insert(String name) {
     UUOne one = new UUOne();
     one.setName("testBLWCH" + name);
-    Ebean.save(one);
+    DB.save(one);
     return one;
   }
 
   @Test
   public void testOnCacheHit() {
-
-    ArrayList<UUOne> inserted = insertData();
-
+    List<UUOne> inserted = insertData();
     clearCacheAndStatistics();
 
-    UUOne b = Ebean.find(UUOne.class, inserted.get(1).getId());
-    assertNotNull(b);
-
-    UUOne b2 = Ebean.find(UUOne.class, inserted.get(1).getId());
-    assertNotNull(b2);
-
+    assertNotNull(DB.find(UUOne.class, inserted.get(1).getId()));
+    // cache hit
+    assertNotNull(DB.find(UUOne.class, inserted.get(1).getId()));
     assertBeanCacheHits(1);
 
-    UUOne c = Ebean.find(UUOne.class)
-      .where().idEq(inserted.get(2).getId())
-      .findOne();
-    assertNotNull(c);
-
-    UUOne c2 = Ebean.find(UUOne.class)
-      .where().idEq(inserted.get(2).getId())
-      .findOne();
-
-    assertNotNull(c2);
+    assertNotNull(DB.find(UUOne.class).where().idEq(inserted.get(2).getId()).findOne());
+    // cache hit
+    assertNotNull(DB.find(UUOne.class).where().idEq(inserted.get(2).getId()).findOne());
     assertBeanCacheHits(1);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<UUOne> list = Ebean.find(UUOne.class)
-      //.setDefaultLazyLoadBatchSize(5)
+    List<UUOne> list = DB.find(UUOne.class)
       .select("id")
       .where().startsWith("name", "testBLWCH")
       .order("name")
       .findList();
 
+    // invoke lazy loading
     for (UUOne uuOne : list) {
       uuOne.getName();
     }
     list.get(0).getName();
 
-    List<String> sql = LoggedSqlCollector.stop();
-    System.out.println("sql:" + sql);
-
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("from uuone t0 where t0.name like ");
     platformAssertIn(sql.get(1), "from uuone t0 where t0.id");
 
     // not lazy loading into bean cache
-    int size = beanCache.getStatistics(true).getSize();
-    assertThat(size).isEqualTo(2);
+    final ServerCacheStatistics stats = beanCache.statistics(true);
+    assertThat(stats.getHitCount()).isEqualTo(10);
+    assertThat(stats.getSize()).isEqualTo(10);
   }
 
   private void assertBeanCacheHits(int hits) {
-    ServerCacheStatistics statistics = beanCache.getStatistics(true);
+    ServerCacheStatistics statistics = beanCache.statistics(true);
     assertEquals(statistics.getHitCount(), hits);
   }
 
   private void clearCacheAndStatistics() {
-
     beanCache.clear();
-    beanCache.getStatistics(true);
+    beanCache.statistics(true);
   }
 
-  private ArrayList<UUOne> insertData() {
-    ArrayList<UUOne> inserted = new ArrayList<>();
+  private List<UUOne> insertData() {
+    List<UUOne> inserted = new ArrayList<>();
     String[] names = "A,B,C,D,E,F,G,H,I,J".split(",");
     for (String name : names) {
       inserted.add(insert(name));
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestBatchLazyWithDeleted.java b/ebean-test/src/test/java/org/tests/batchload/TestBatchLazyWithDeleted.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/batchload/TestBatchLazyWithDeleted.java
rename to ebean-test/src/test/java/org/tests/batchload/TestBatchLazyWithDeleted.java
index a91cbbd76..dbb650815 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestBatchLazyWithDeleted.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestBatchLazyWithDeleted.java
@@ -1,23 +1,24 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UUOne;
 import org.tests.model.basic.UUTwo;
-import org.junit.Assert;
-import org.junit.Test;
 
 import javax.persistence.EntityNotFoundException;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestBatchLazyWithDeleted extends BaseTestCase {
 
   @Test
   public void testOnDeleted() {
 
-    Ebean.deleteAll(Ebean.find(UUTwo.class).findList());
-    Ebean.deleteAll(Ebean.find(UUOne.class).findList());
+    DB.deleteAll(DB.find(UUTwo.class).findList());
+    DB.deleteAll(DB.find(UUOne.class).findList());
 
     UUOne oneA = new UUOne();
     oneA.setName("oneA");
@@ -37,13 +38,13 @@ public class TestBatchLazyWithDeleted extends BaseTestCase {
     twoC.setName("two-bld-C");
     twoC.setMaster(oneB);
 
-    Ebean.save(oneA);
-    Ebean.save(oneB);
-    Ebean.save(two);
-    Ebean.save(twoB);
-    Ebean.save(twoC);
+    DB.save(oneA);
+    DB.save(oneB);
+    DB.save(two);
+    DB.save(twoB);
+    DB.save(twoC);
 
-    List<UUTwo> list = Ebean.find(UUTwo.class)
+    List<UUTwo> list = DB.find(UUTwo.class)
       .fetchLazy("master")
       .where().startsWith("name", "two-bld-")
       .order("name")
@@ -52,13 +53,13 @@ public class TestBatchLazyWithDeleted extends BaseTestCase {
     // delete a bean that will be batch lazy loaded but
     // is NOT the bean that will invoke the lazy loading
     // (in this case it is the second bean in the list).
-    int deletedCount = Ebean.delete(UUOne.class, oneB.getId());
-    Assert.assertEquals(1, deletedCount);
+    int deletedCount = DB.delete(UUOne.class, oneB.getId());
+    assertEquals(1, deletedCount);
 
     for (UUTwo u : list) {
       u.getMaster();
-      //BeanState beanState = Ebean.getBeanState(master);
-      //Assert.assertTrue(beanState.isReference());
+      //BeanState beanState = DB.beanState(master);
+      //assertTrue(beanState.isReference());
     }
 
     // invoke lazy loading on the second 'master' bean
@@ -73,10 +74,10 @@ public class TestBatchLazyWithDeleted extends BaseTestCase {
     // it was removed from the "lazy load context" earlier
     try {
       list.get(2).getMaster().getName();
-      Assert.assertTrue(false);
+      assertTrue(false);
     } catch (EntityNotFoundException e) {
       // this bean was deleted and lazy loading failed
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
 
 
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestBeanState.java b/ebean-test/src/test/java/org/tests/batchload/TestBeanState.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/batchload/TestBeanState.java
rename to ebean-test/src/test/java/org/tests/batchload/TestBeanState.java
index 28161dc3d..2f244435e 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestBeanState.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestBeanState.java
@@ -5,7 +5,7 @@ import io.ebean.BeanState;
 import io.ebean.DB;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -13,7 +13,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 
 public class TestBeanState extends BaseTestCase {
@@ -29,15 +29,15 @@ public class TestBeanState extends BaseTestCase {
       .setUseCache(false)
       .findOne();
 
-    BeanState beanState = DB.getBeanState(customer);
+    BeanState beanState = DB.beanState(customer);
     assertFalse(beanState.isNew());
     assertFalse(beanState.isDirty());
     assertFalse(beanState.isNewOrDirty());
-    assertNotNull(beanState.getLoadedProps());
+    assertNotNull(beanState.loadedProps());
 
     customer.setName("dirtyNameProp");
     assertTrue(beanState.isDirty());
-    assertThat(beanState.getChangedProps()).containsOnly("name");
+    assertThat(beanState.changedProps()).containsOnly("name");
 
     EntityBeanIntercept ebi = ((EntityBean) customer)._ebean_getIntercept();
     boolean[] dirtyProperties = ebi.getDirtyProperties();
@@ -51,7 +51,7 @@ public class TestBeanState extends BaseTestCase {
     customer.setStatus(Customer.Status.INACTIVE);
 
     assertTrue(beanState.isDirty());
-    assertThat(beanState.getChangedProps()).containsOnly("name", "status");
+    assertThat(beanState.changedProps()).containsOnly("name", "status");
   }
 
   @Test
@@ -67,7 +67,7 @@ public class TestBeanState extends BaseTestCase {
       .setUseCache(false)
       .findOne();
 
-    BeanState beanState = DB.getBeanState(customer);
+    BeanState beanState = DB.beanState(customer);
     beanState.setDisableLazyLoad(true);
     assertNull(customer.getName());
   }
@@ -79,11 +79,11 @@ public class TestBeanState extends BaseTestCase {
 
     Customer customer = DB.find(Customer.class).order("id").setMaxRows(1).findOne();
 
-    BeanState beanState = DB.getBeanState(customer);
-    assertThat(beanState.getChangedProps()).isEmpty();
+    BeanState beanState = DB.beanState(customer);
+    assertThat(beanState.changedProps()).isEmpty();
 
     customer.setContacts(new ArrayList<>());
-    assertThat(beanState.getChangedProps()).containsOnly("contacts");
+    assertThat(beanState.changedProps()).containsOnly("contacts");
   }
 
   @Test
@@ -91,47 +91,44 @@ public class TestBeanState extends BaseTestCase {
 
     Customer customer = new Customer();
 
-    BeanState beanState = DB.getBeanState(customer);
-    assertThat(beanState.getChangedProps()).isEmpty();
+    BeanState beanState = DB.beanState(customer);
+    assertThat(beanState.changedProps()).isEmpty();
 
     // when new state, then loaded
     customer.setContacts(new ArrayList<>());
-    assertThat(beanState.getChangedProps()).isEmpty();
-    assertThat(beanState.getLoadedProps()).containsOnly("contacts");
+    assertThat(beanState.changedProps()).isEmpty();
+    assertThat(beanState.loadedProps()).containsOnly("contacts");
 
     // set loaded state, then marked as changed
     beanState.setLoaded();
     customer.setContacts(new ArrayList<>());
-    assertThat(beanState.getLoadedProps()).containsOnly("contacts");
-    assertThat(beanState.getChangedProps()).containsOnly("contacts");
+    assertThat(beanState.loadedProps()).containsOnly("contacts");
+    assertThat(beanState.changedProps()).containsOnly("contacts");
   }
 
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void readOnly_when_setManyProperty() {
-
     Customer customer = new Customer();
     customer.setContacts(new ArrayList<>());
 
-    BeanState beanState = DB.getBeanState(customer);
+    BeanState beanState = DB.beanState(customer);
     beanState.setLoaded();
     beanState.setReadOnly(true);
 
     // act, try to mutate read only bean
-    customer.setContacts(new ArrayList<>());
+    assertThrows(IllegalStateException.class, () -> customer.setContacts(new ArrayList<>()));
   }
 
-
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void readOnly_when_setProperty() {
-
     Customer customer = new Customer();
     customer.setName("a");
 
-    BeanState beanState = DB.getBeanState(customer);
+    BeanState beanState = DB.beanState(customer);
     beanState.setLoaded();
     beanState.setReadOnly(true);
 
     // act, try to mutate read only bean
-    customer.setName("b");
+    assertThrows(IllegalStateException.class, () -> customer.setName("b"));
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestEmptyManyLazyLoad.java b/ebean-test/src/test/java/org/tests/batchload/TestEmptyManyLazyLoad.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/batchload/TestEmptyManyLazyLoad.java
rename to ebean-test/src/test/java/org/tests/batchload/TestEmptyManyLazyLoad.java
index 40be470a8..c2b797bb7 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestEmptyManyLazyLoad.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestEmptyManyLazyLoad.java
@@ -1,8 +1,8 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.Order.Status;
@@ -15,19 +15,19 @@ public class TestEmptyManyLazyLoad extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Customer c = Ebean.find(Customer.class).findList().get(0);
+    Customer c = DB.find(Customer.class).findList().get(0);
 
     Order o = new Order();
     o.setCustomer(c);
     o.setStatus(Status.NEW);
 
-    Ebean.save(o);
+    DB.save(o);
 
-    Order o2 = Ebean.find(Order.class, o.getId());
+    Order o2 = DB.find(Order.class, o.getId());
     o2.getDetails().size();
 
     // cleanup
-    Ebean.delete(o2);
+    DB.delete(o2);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestLazyJoin.java b/ebean-test/src/test/java/org/tests/batchload/TestLazyJoin.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/batchload/TestLazyJoin.java
rename to ebean-test/src/test/java/org/tests/batchload/TestLazyJoin.java
index bd15f2f6d..8dd286907 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestLazyJoin.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestLazyJoin.java
@@ -1,17 +1,18 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestLazyJoin extends BaseTestCase {
 
   @Test
@@ -19,7 +20,7 @@ public class TestLazyJoin extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status")
       .fetchLazy("customer", "name, status")
       .fetch("customer.contacts")
@@ -36,7 +37,7 @@ public class TestLazyJoin extends BaseTestCase {
     // in the customer (not just name and status)
     Address billingAddress = customer.getBillingAddress();
 
-    Assert.assertNotNull(billingAddress);
+    assertNotNull(billingAddress);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestLazyJoin2.java b/ebean-test/src/test/java/org/tests/batchload/TestLazyJoin2.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/batchload/TestLazyJoin2.java
rename to ebean-test/src/test/java/org/tests/batchload/TestLazyJoin2.java
index b44e173dc..79a1daaf7 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestLazyJoin2.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestLazyJoin2.java
@@ -1,18 +1,15 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
-import org.tests.model.basic.Address;
-import org.tests.model.basic.Contact;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestLazyJoin2 extends BaseTestCase {
 
   @Test
@@ -21,7 +18,7 @@ public class TestLazyJoin2 extends BaseTestCase {
     ResetBasicData.reset();
 
     // This will use 3 SQL queries to build this object graph
-    List<Order> l0 = Ebean.find(Order.class).select("status, shipDate")
+    List<Order> l0 = DB.find(Order.class).select("status, shipDate")
 
       .fetchQuery("details", "orderQty, unitPrice")
       .fetch("details.product", "sku, name")
@@ -33,7 +30,7 @@ public class TestLazyJoin2 extends BaseTestCase {
     Order o0 = l0.get(0);
     Customer c0 = o0.getCustomer();
     List<Contact> contacts = c0.getContacts();
-    Assert.assertTrue(!contacts.isEmpty());
+    assertTrue(!contacts.isEmpty());
 
     // query 1) find order (status, shipDate)
     // query 2) find orderDetail (quantity, price) join product (sku, name)
@@ -41,7 +38,7 @@ public class TestLazyJoin2 extends BaseTestCase {
     // query 3) find customer (name) join contacts (*) join shippingAddress (*)
     // where id in (?,?,?,?,?)
 
-    List<Order> orders = Ebean.find(Order.class)
+    List<Order> orders = DB.find(Order.class)
       // .select("status")
       .fetchQuery("customer").order().asc("id").findList();
     // .join("customer.contacts");
@@ -57,9 +54,9 @@ public class TestLazyJoin2 extends BaseTestCase {
     // in the customer (not just name and status)
     Address billingAddress = customer.getBillingAddress();
 
-    Assert.assertNotNull(billingAddress);
+    assertNotNull(billingAddress);
 
-    List<Order> list = Ebean.find(Order.class).fetchLazy("customer", "name")
+    List<Order> list = DB.find(Order.class).fetchLazy("customer", "name")
       .fetch("customer.contacts", "contactName, phone, email").fetch("customer.shippingAddress")
       .where().eq("status", Order.Status.NEW).order().asc("id").findList();
 
@@ -67,7 +64,7 @@ public class TestLazyJoin2 extends BaseTestCase {
     Customer customer2 = order2.getCustomer();
     // customer2.getStatus();
     String name = customer2.getName();
-    Assert.assertNotNull(name);
+    assertNotNull(name);
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestLazyLoadEmptyCollection.java b/ebean-test/src/test/java/org/tests/batchload/TestLazyLoadEmptyCollection.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/batchload/TestLazyLoadEmptyCollection.java
rename to ebean-test/src/test/java/org/tests/batchload/TestLazyLoadEmptyCollection.java
index 8f8c770aa..d819dbe2f 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestLazyLoadEmptyCollection.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestLazyLoadEmptyCollection.java
@@ -1,12 +1,10 @@
 package org.tests.batchload;
 
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
 import io.ebean.TransactionalTestCase;
-
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -21,9 +19,9 @@ public class TestLazyLoadEmptyCollection extends TransactionalTestCase {
     Contact con = new Contact("jim", "slim");
     c.addContact(con);
 
-    Ebean.save(c);
+    DB.save(c);
 
-    List<Customer> list = Ebean.find(Customer.class)
+    List<Customer> list = DB.find(Customer.class)
       .fetchQuery("contacts")
       .fetchQuery("contacts.notes")
       .findList();
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestLazyLoadNonExistantBean.java b/ebean-test/src/test/java/org/tests/batchload/TestLazyLoadNonExistantBean.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/batchload/TestLazyLoadNonExistantBean.java
rename to ebean-test/src/test/java/org/tests/batchload/TestLazyLoadNonExistantBean.java
index 0beb20db4..6766cfe9a 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestLazyLoadNonExistantBean.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestLazyLoadNonExistantBean.java
@@ -1,29 +1,30 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UUOne;
-import org.junit.Assert;
-import org.junit.Test;
 
 import javax.persistence.EntityNotFoundException;
 import java.util.UUID;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestLazyLoadNonExistantBean extends BaseTestCase {
 
   @Test
   public void testSimple() {
 
     UUID uuid = UUID.randomUUID();
-    UUOne one = Ebean.getReference(UUOne.class, uuid);
+    UUOne one = DB.reference(UUOne.class, uuid);
 
     try {
       // invoke lazy loading
       one.getName();
-      Assert.assertTrue(false);
+      assertTrue(false);
     } catch (EntityNotFoundException e) {
       // expecting this
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestLazyLoadNonExistentBean.java b/ebean-test/src/test/java/org/tests/batchload/TestLazyLoadNonExistentBean.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/batchload/TestLazyLoadNonExistentBean.java
rename to ebean-test/src/test/java/org/tests/batchload/TestLazyLoadNonExistentBean.java
index 966080ba8..0eabc9570 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestLazyLoadNonExistentBean.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestLazyLoadNonExistentBean.java
@@ -1,29 +1,30 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UUOne;
-import org.junit.Assert;
-import org.junit.Test;
 
 import javax.persistence.EntityNotFoundException;
 import java.util.UUID;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestLazyLoadNonExistentBean extends BaseTestCase {
 
   @Test
   public void testSimple() {
 
     UUID uuid = UUID.randomUUID();
-    UUOne one = Ebean.getReference(UUOne.class, uuid);
+    UUOne one = DB.reference(UUOne.class, uuid);
 
     try {
       // invoke lazy loading
       one.getName();
-      Assert.assertTrue(false);
+      assertTrue(false);
     } catch (EntityNotFoundException e) {
       // expecting this
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestQueryDisableLazyLoad.java b/ebean-test/src/test/java/org/tests/batchload/TestQueryDisableLazyLoad.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/batchload/TestQueryDisableLazyLoad.java
rename to ebean-test/src/test/java/org/tests/batchload/TestQueryDisableLazyLoad.java
index e446ae57b..deae22962 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestQueryDisableLazyLoad.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestQueryDisableLazyLoad.java
@@ -1,18 +1,18 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.ResetBasicData;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestQueryDisableLazyLoad extends BaseTestCase {
 
@@ -21,9 +21,9 @@ public class TestQueryDisableLazyLoad extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Order> l0 = Ebean.find(Order.class)
+    List<Order> l0 = DB.find(Order.class)
       .setDisableLazyLoading(true)
       .order().asc("id")
       .findList();
@@ -35,7 +35,7 @@ public class TestQueryDisableLazyLoad extends BaseTestCase {
     List<OrderDetail> details = order.getDetails();
     assertEquals(details.size(), 0);
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
 
     assertThat(trimSql(loggedSql.get(0), 2)).contains("select t0.id, t0.status, t0.order_date,");
@@ -47,9 +47,9 @@ public class TestQueryDisableLazyLoad extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Order> l0 = Ebean.find(Order.class)
+    List<Order> l0 = DB.find(Order.class)
       .setDisableLazyLoading(true)
       .order().asc("id")
       .findList();
@@ -61,7 +61,7 @@ public class TestQueryDisableLazyLoad extends BaseTestCase {
     // normally invokes lazy loading
     assertNull(order.getCustomer().getStatus());
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
   }
 
@@ -70,9 +70,9 @@ public class TestQueryDisableLazyLoad extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Order> l0 = Ebean.find(Order.class)
+    List<Order> l0 = DB.find(Order.class)
       .setDisableLazyLoading(true)
       .fetch("customer", "smallnote")
       .order().asc("id")
@@ -85,7 +85,7 @@ public class TestQueryDisableLazyLoad extends BaseTestCase {
     // normally invokes lazy loading
     assertNull(order.getCustomer().getStatus());
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
   }
 }
diff --git a/ebean-test/src/test/java/org/tests/batchload/TestQueryJoin.java b/ebean-test/src/test/java/org/tests/batchload/TestQueryJoin.java
new file mode 100644
index 000000000..64a88e1f1
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/batchload/TestQueryJoin.java
@@ -0,0 +1,61 @@
+package org.tests.batchload;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.DB;
+import io.ebean.Query;
+import io.ebean.cache.ServerCache;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestQueryJoin extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    // Need to make sure the customer cache is cleared for the later
+    // asserts on the lazy loading
+    ServerCache custCache = DB.cacheManager().beanCache(Customer.class);
+    custCache.clear();
+
+    Query<Order> query = DB.find(Order.class).select("status")
+      .fetchLazy("customer", "name, status")
+      .fetch("customer.contacts").order().asc("id");
+
+    List<Order> list = query.findList();
+
+    // list.get(0).getShipDate();
+
+    Order order = list.get(0);
+    BeanState beanStateOrder = DB.beanState(order);
+    assertNotNull(beanStateOrder.loadedProps());
+    // assertTrue(beanStateOrder.getLoadedProps().contains("id"));
+    assertThat(beanStateOrder.loadedProps()).contains("status", "shipments", "customer");
+
+    Customer customer = order.getCustomer();
+    BeanState beanStateCustomer = DB.beanState(customer);
+    assertTrue(beanStateCustomer.isReference());
+
+    customer.getName();
+    assertNotNull(beanStateCustomer.loadedProps());
+    assertThat(beanStateCustomer.loadedProps()).contains("name", "status");
+    assertThat(beanStateCustomer.loadedProps()).doesNotContain("billingAddress");
+
+    customer.getName();
+
+    Address billingAddress = customer.getBillingAddress();
+    billingAddress.getLine1();
+
+    assertFalse(list.isEmpty());
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestQueryJoinToAssocOne.java b/ebean-test/src/test/java/org/tests/batchload/TestQueryJoinToAssocOne.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/batchload/TestQueryJoinToAssocOne.java
rename to ebean-test/src/test/java/org/tests/batchload/TestQueryJoinToAssocOne.java
index 04883177e..03386f656 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestQueryJoinToAssocOne.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestQueryJoinToAssocOne.java
@@ -1,10 +1,9 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.ResetBasicData;
@@ -25,17 +24,17 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // This will use 2 SQL queries to build this object graph
-    List<Order> l0 = Ebean.find(Order.class)
+    List<Order> l0 = DB.find(Order.class)
       .fetchQuery("details", "orderQty, unitPrice")
       .fetch("details.product", "sku, name")
       .findList();
 
     assertThat(l0).isNotEmpty();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(2);
 
     String secondaryQuery = trimSql(loggedSql.get(1), 1);
@@ -51,10 +50,10 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // This will use 2 SQL queries to build this object graph
-    List<Order> l0 = Ebean.find(Order.class)
+    List<Order> l0 = DB.find(Order.class)
       .select("status, shipDate")
       .fetchQuery("details", "orderQty, unitPrice")
       .fetch("details.product", "sku, name")
@@ -62,7 +61,7 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
 
     assertThat(l0).isNotEmpty();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(2);
 
     String secondaryQuery = trimSql(loggedSql.get(1), 1);
@@ -77,10 +76,10 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // This will use 2 SQL queries to build this object graph
-    List<Order> l0 = Ebean.find(Order.class)
+    List<Order> l0 = DB.find(Order.class)
       .setDisableLazyLoading(true)
       .select("status, shipDate")
       .fetchQuery("details", "orderQty, unitPrice")
@@ -102,7 +101,7 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
     // normally invokes lazy loading
     order.getShipments().size();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(2);
 
     String secondaryQuery = trimSql(loggedSql.get(1), 1);
@@ -117,10 +116,10 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // This will use 2 SQL queries to build this object graph
-    List<Order> l0 = Ebean.find(Order.class)
+    List<Order> l0 = DB.find(Order.class)
       .setDisableLazyLoading(true)
       .select("status, shipDate")
       .order().asc("id")
@@ -138,7 +137,7 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
     assertThat(details).isEmpty();
     assertThat(details.size()).isEqualTo(0);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
   }
 
@@ -147,18 +146,18 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
 
     Role role0 = new Role("r0");
     Role role1 = new Role("r1");
-    Ebean.save(role0);
-    Ebean.save(role1);
+    DB.save(role0);
+    DB.save(role1);
 
     Tenant tenant = new Tenant("t0");
     tenant.getRoles().add(role0);
     tenant.getRoles().add(role1);
 
-    Ebean.save(tenant);
+    DB.save(tenant);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Tenant found = Ebean.find(Tenant.class)
+    Tenant found = DB.find(Tenant.class)
       .setDisableLazyLoading(true)
       .select("name")
       .setId(tenant.getId())
@@ -166,7 +165,7 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
 
     assertThat(found.getRoles().size()).isEqualTo(0);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
   }
 
@@ -179,11 +178,11 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
     MpUser u = new MpUser();
     u.setName("disableLazy");
     u.getRoles().put("disableLazyLoading", r0);
-    Ebean.save(u);
+    DB.save(u);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    MpUser found = Ebean.find(MpUser.class)
+    MpUser found = DB.find(MpUser.class)
       .setDisableLazyLoading(true)
       .select("name")
       .setId(u.getId())
@@ -193,10 +192,10 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
     assertThat(found.getRoles().size()).isEqualTo(0);
 
     // only 1 query ... no lazy loading query
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
 
-    Ebean.deleteAll(Arrays.asList(found, r0));
+    DB.deleteAll(Arrays.asList(found, r0));
   }
 
   @Test
@@ -204,10 +203,10 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // This will use 2 SQL queries to build this object graph
-    List<Order> l0 = Ebean.find(Order.class)
+    List<Order> l0 = DB.find(Order.class)
       .setDisableLazyLoading(true)
       .select("status, shipDate")
       .fetch("details", "orderQty, unitPrice")//, new FetchConfig().query())
@@ -225,7 +224,7 @@ public class TestQueryJoinToAssocOne extends BaseTestCase {
     // normally invokes lazy loading
     orderDetail.getShipQty();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
 
     String originQuery = trimSql(loggedSql.get(0), 5);
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestSecondQueryNoRows.java b/ebean-test/src/test/java/org/tests/batchload/TestSecondQueryNoRows.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/batchload/TestSecondQueryNoRows.java
rename to ebean-test/src/test/java/org/tests/batchload/TestSecondQueryNoRows.java
index e8a21786c..ac0127398 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestSecondQueryNoRows.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestSecondQueryNoRows.java
@@ -1,14 +1,13 @@
 package org.tests.batchload;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestSecondQueryNoRows extends BaseTestCase {
 
@@ -20,9 +19,9 @@ public class TestSecondQueryNoRows extends BaseTestCase {
     Customer cnew = new Customer();
     cnew.setName("testSecQueryNoRows");
 
-    Ebean.save(cnew);
+    DB.save(cnew);
 
-    Customer c = Ebean.find(Customer.class)
+    Customer c = DB.find(Customer.class)
       .setAutoTune(false)
       .setId(cnew.getId())
       .fetchQuery("contacts")
@@ -31,6 +30,6 @@ public class TestSecondQueryNoRows extends BaseTestCase {
     assertNotNull(c);
     assertEquals(0, c.getContacts().size());
 
-    Ebean.delete(c);
+    DB.delete(c);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/batchload/TestSecondaryQueries.java b/ebean-test/src/test/java/org/tests/batchload/TestSecondaryQueries.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/batchload/TestSecondaryQueries.java
rename to ebean-test/src/test/java/org/tests/batchload/TestSecondaryQueries.java
index b61b1fbac..ffa0a5608 100644
--- a/ebean-core/src/test/java/org/tests/batchload/TestSecondaryQueries.java
+++ b/ebean-test/src/test/java/org/tests/batchload/TestSecondaryQueries.java
@@ -1,12 +1,11 @@
 package org.tests.batchload;
 
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.QueryIterator;
 import io.ebean.TransactionalTestCase;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
@@ -14,23 +13,21 @@ import org.tests.model.basic.ResetBasicData;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestSecondaryQueries extends TransactionalTestCase {
 
   @Test
   public void fetchQuery() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .select("status")
       .fetchQuery("customer", "name")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(2);
     assertThat(trimSql(sql.get(0), 2)).contains("select t0.id, t0.status, t0.kcustomer_id from o_order t0");
@@ -41,16 +38,17 @@ public class TestSecondaryQueries extends TransactionalTestCase {
   @Test
   public void fetchLazy() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
+    DB.cacheManager().clearAll();
 
-    List<Order> orders = Ebean.find(Order.class)
+    List<Order> orders = DB.find(Order.class)
       .select("status")
       .fetchLazy("customer", "name")
       .setMaxRows(10)
       .setUseCache(false)
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(1);
     if (isSqlServer()) {
@@ -59,14 +57,14 @@ public class TestSecondaryQueries extends TransactionalTestCase {
       assertThat(trimSql(sql.get(0), 2)).contains("select t0.id, t0.status, t0.kcustomer_id from o_order t0");
     }
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // invoke lazy loading
     for (Order order : orders) {
       order.getCustomer().getName();
     }
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertThat(trimSql(sql.get(0), 1)).contains("select t0.id, t0.name from o_customer t0 where t0.id");
     platformAssertIn(sql.get(0), " where t0.id");
@@ -75,10 +73,10 @@ public class TestSecondaryQueries extends TransactionalTestCase {
   @Test
   public void fetchIterate() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     try (QueryIterator<Order> orders =
-           Ebean.find(Order.class).select("status")
+           DB.find(Order.class).select("status")
         .setMaxRows(10)
         .setUseCache(false)
         .findIterate()) {
@@ -87,7 +85,7 @@ public class TestSecondaryQueries extends TransactionalTestCase {
         orders.next(); // dummy read
       }
     }
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(1);
     if (isSqlServer()) {
@@ -103,17 +101,17 @@ public class TestSecondaryQueries extends TransactionalTestCase {
     Order testOrder = ResetBasicData.createOrderCustAndOrder("testSecQry10");
     Integer custId = testOrder.getCustomer().getId();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("name")
       .fetchQuery("contacts")
       .setId(custId);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Customer cust = query.findOne();
     assertNotNull(cust);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     String generatedSql = query.getGeneratedSql();
     assertThat(generatedSql).contains("from o_customer t0 where t0.id = ?");
@@ -127,7 +125,7 @@ public class TestSecondaryQueries extends TransactionalTestCase {
   @Test
   public void testManyToOneWithManyPlusOneToMany() {
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .select("status")
       .fetchQuery("customer", "name, status")
       .fetch("customer.contacts")
@@ -136,7 +134,7 @@ public class TestSecondaryQueries extends TransactionalTestCase {
       .query();
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Order> list = query.findList();
     assertTrue(!list.isEmpty());
@@ -145,7 +143,7 @@ public class TestSecondaryQueries extends TransactionalTestCase {
       order.getCustomer().getStatus();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     String generatedSql = sqlOf(query, 2);
     //select t0.id c0, t0.status c1, t0.kcustomer_id c2 from o_order t0 where t0.status = ? ; --bind(NEW)
diff --git a/ebean-core/src/test/java/org/tests/cache/TestBeanCache.java b/ebean-test/src/test/java/org/tests/cache/TestBeanCache.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/cache/TestBeanCache.java
rename to ebean-test/src/test/java/org/tests/cache/TestBeanCache.java
index 99e40879d..f36936807 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestBeanCache.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestBeanCache.java
@@ -5,8 +5,8 @@ import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheStatistics;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Country;
@@ -18,7 +18,7 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 /**
  * Test class testing deleting/invalidating of cached beans
@@ -27,7 +27,7 @@ public class TestBeanCache extends BaseTestCase {
 
   private static final Logger log = LoggerFactory.getLogger(TestBeanCache.class);
 
-  private final ServerCache beanCache = DB.getDefault().getServerCacheManager().getBeanCache(OCachedBean.class);
+  private final ServerCache beanCache = DB.getDefault().cacheManager().beanCache(OCachedBean.class);
 
   @Test
   public void findById_when_idTypeConverted() {
@@ -40,16 +40,16 @@ public class TestBeanCache extends BaseTestCase {
     assertNotNull(bean0);
 
     // expect to hit the cache, no SQL
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     OCachedBean bean1 = DB.find(OCachedBean.class, bean.getId());
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertNotNull(bean1);
     assertThat(sql).isEmpty();
 
     // expect to hit the cache, no SQL
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     OCachedBean bean2 = DB.find(OCachedBean.class).setReadOnly(true).setId(String.valueOf(bean.getId())).findOne();
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertNotNull(bean2);
     assertThat(sql).isEmpty();
   }
@@ -61,7 +61,7 @@ public class TestBeanCache extends BaseTestCase {
     List<Long> ids = beans.stream().map(OCachedBean::getId).collect(Collectors.toList());
 
     beanCache.clear();
-    beanCache.getStatistics(true);
+    beanCache.statistics(true);
     try (Transaction transaction = DB.beginTransaction()) {
 
       // skipCacheAfterWrite set after this write ...
@@ -77,7 +77,7 @@ public class TestBeanCache extends BaseTestCase {
       transaction.commit();
     }
 
-    ServerCacheStatistics statistics = beanCache.getStatistics(true);
+    ServerCacheStatistics statistics = beanCache.statistics(true);
     assertThat(statistics.getHitCount()).isEqualTo(0);
     assertThat(statistics.getMissCount()).isEqualTo(2);
     assertThat(statistics.getPutCount()).isEqualTo(2);
@@ -90,9 +90,9 @@ public class TestBeanCache extends BaseTestCase {
     List<Long> ids = beans.stream().map(OCachedBean::getId).collect(Collectors.toList());
 
     beanCache.clear();
-    beanCache.getStatistics(true);
+    beanCache.statistics(true);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     log.info("All misses (0 of 3) ...");
     List<OCachedBean> list = DB.find(OCachedBean.class)
@@ -102,7 +102,7 @@ public class TestBeanCache extends BaseTestCase {
 
     assertThat(list).hasSize(3);
     assertBeanCacheHitMiss(0, 3);
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     if (isH2()) {
       assertSql(sql.get(0)).contains("from o_cached_bean t0 where t0.id in (?,?,?,?,?)");
@@ -116,7 +116,7 @@ public class TestBeanCache extends BaseTestCase {
 
     assertBeanCacheHitMiss(3, 0);
     assertThat(list).hasSize(3);
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(0); // no misses
 
     // remove a bean so that we get a "partial" hit (2 out of 3 in cache)
@@ -130,7 +130,7 @@ public class TestBeanCache extends BaseTestCase {
 
     assertBeanCacheHitMiss(2, 1);
     assertThat(list).hasSize(3);
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     if (isH2()) {
       // fetch the miss from DB
@@ -149,7 +149,7 @@ public class TestBeanCache extends BaseTestCase {
 
     assertBeanCacheHitMiss(1, 2);
     assertThat(list).hasSize(3);
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isH2()) {
       // fetch the misses from DB
@@ -158,7 +158,7 @@ public class TestBeanCache extends BaseTestCase {
   }
 
   private void assertBeanCacheHitMiss(int hitCount, int missCount) {
-    ServerCacheStatistics statistics = beanCache.getStatistics(true);
+    ServerCacheStatistics statistics = beanCache.statistics(true);
     assertThat(statistics.getHitCount()).isEqualTo(hitCount);
     assertThat(statistics.getMissCount()).isEqualTo(missCount);
   }
diff --git a/ebean-core/src/test/java/org/tests/cache/TestBeanCacheContactLazyLoad.java b/ebean-test/src/test/java/org/tests/cache/TestBeanCacheContactLazyLoad.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/cache/TestBeanCacheContactLazyLoad.java
rename to ebean-test/src/test/java/org/tests/cache/TestBeanCacheContactLazyLoad.java
index 9eb438032..617737c52 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestBeanCacheContactLazyLoad.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestBeanCacheContactLazyLoad.java
@@ -2,8 +2,8 @@ package org.tests.cache;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebeantest.LoggedSql;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 
diff --git a/ebean-test/src/test/java/org/tests/cache/TestBeanCacheWithDeleteQuery.java b/ebean-test/src/test/java/org/tests/cache/TestBeanCacheWithDeleteQuery.java
new file mode 100644
index 000000000..069287b91
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/cache/TestBeanCacheWithDeleteQuery.java
@@ -0,0 +1,80 @@
+package org.tests.cache;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.OCachedBean;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Test class testing clearing cache with delete query
+ */
+public class TestBeanCacheWithDeleteQuery extends BaseTestCase {
+
+  @Test
+  public void testBeanCacheGetsClearedOnDelete() {
+
+    OCachedBean bean = new OCachedBean();
+    bean.setName("cache-invalidation");
+    DB.save(bean);
+
+    OCachedBean bean0 = DB.find(OCachedBean.class, bean.getId());
+    assertNotNull(bean0);
+
+    // expect to hit the cache, no SQL
+    LoggedSql.start();
+    OCachedBean bean1 = DB.find(OCachedBean.class, bean.getId());
+    List<String> sql = LoggedSql.stop();
+    assertNotNull(bean1);
+    assertThat(sql).isEmpty();
+
+    // delete the bean
+    int deleted = DB.createQuery(OCachedBean.class).where().eq("name", "cache-invalidation").delete();
+
+    assertEquals(deleted, 1);
+
+    // expect not to hit the cache, expect SQL
+    LoggedSql.start();
+    OCachedBean bean2 = DB.find(OCachedBean.class).setReadOnly(true).setId(String.valueOf(bean.getId())).findOne();
+    sql = LoggedSql.stop();
+    assertNull(bean2);
+    assertThat(sql).isNotEmpty();
+  }
+
+  @Test
+  public void testBeanCacheGetsClearedOnUpdate() {
+
+    OCachedBean bean = new OCachedBean();
+    bean.setName("cache-invalidation-upd");
+    DB.save(bean);
+
+    OCachedBean bean0 = DB.find(OCachedBean.class, bean.getId());
+    assertNotNull(bean0);
+
+    // expect to hit the cache, no SQL
+    LoggedSql.start();
+    OCachedBean bean1 = DB.find(OCachedBean.class, bean.getId());
+    List<String> sql = LoggedSql.stop();
+    assertNotNull(bean1);
+    assertThat(sql).isEmpty();
+
+    // update the bean
+    int updated = DB.update(OCachedBean.class).set("name", "updatedName").where().eq("name","cache-invalidation-upd").update();
+
+    assertEquals(updated, 1);
+
+    // expect not to hit the cache, expect SQL
+    LoggedSql.start();
+    OCachedBean bean2 = DB.find(OCachedBean.class).setReadOnly(true).setId(String.valueOf(bean.getId())).findOne();
+    sql = LoggedSql.stop();
+    assertNotNull(bean2);
+    assertThat(sql).isNotEmpty();
+    assertEquals("updatedName", bean2.getName());
+  }
+
+}
diff --git a/ebean-core/src/test/java/org/tests/cache/TestBeanFetchJoinCache.java b/ebean-test/src/test/java/org/tests/cache/TestBeanFetchJoinCache.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/cache/TestBeanFetchJoinCache.java
rename to ebean-test/src/test/java/org/tests/cache/TestBeanFetchJoinCache.java
index f036dded5..c7a45d5e6 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestBeanFetchJoinCache.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestBeanFetchJoinCache.java
@@ -5,8 +5,8 @@ import io.ebean.DB;
 import io.ebean.FetchGroup;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheStatistics;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
@@ -18,26 +18,24 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestBeanFetchJoinCache extends BaseTestCase {
 
-  private final ServerCache customerBeanCache = server().getServerCacheManager().getBeanCache(Customer.class);
+  private final ServerCache customerBeanCache = server().cacheManager().beanCache(Customer.class);
 
   @Test
   public void fetchCache_when_allHits() {
-
     initDataClearCache();
     loadCustomerBeanCache();
+    customerBeanCache.statistics(true);
 
-    customerBeanCache.getStatistics(true);
-
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Order> orders = DB.find(Order.class)
       .fetchCache("customer", "status, name")
       .findList();
 
-    final List<String> sql0 = LoggedSqlCollector.current();
+    final List<String> sql0 = LoggedSql.collect();
     assertThat(sql0).hasSize(1);
 
-    final ServerCacheStatistics statistics = customerBeanCache.getStatistics(true);
+    final ServerCacheStatistics statistics = customerBeanCache.statistics(true);
     assertThat(statistics.getHitCount()).isEqualTo(2);
 
     assertThat(trimSql(sql0.get(0))).doesNotContain("t1.status");
@@ -48,7 +46,7 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
       assertThat(customer.getStatus()).isNotNull();
     }
 
-    assertThat(LoggedSqlCollector.stop()).isEmpty();
+    assertThat(LoggedSql.stop()).isEmpty();
   }
 
   private void loadCustomerBeanCache() {
@@ -59,7 +57,6 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
 
   @Test
   public void fetchCache_when_someHits() {
-
     initDataClearCache();
 
     DB.find(Customer.class)
@@ -67,20 +64,20 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
       .where().lt("id", 2)
       .findList();
 
-    customerBeanCache.getStatistics(true);
+    customerBeanCache.statistics(true);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Order> orders = DB.find(Order.class)
       .fetchCache("customer")
       .findList();
 
-    final List<String> sql0 = LoggedSqlCollector.current();
+    final List<String> sql0 = LoggedSql.collect();
     assertThat(sql0).hasSize(2);
     assertThat(sql0.get(0)).contains(" from o_order ");
     assertThat(sql0.get(1)).contains(" from o_customer t0 where t0.id ");
 
-    final ServerCacheStatistics statistics = customerBeanCache.getStatistics(true);
+    final ServerCacheStatistics statistics = customerBeanCache.statistics(true);
     assertThat(statistics.getHitCount()).isEqualTo(1);
 
     for (Order order : orders) {
@@ -89,12 +86,11 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
       assertThat(customer.getStatus()).isNotNull();
     }
 
-    assertThat(LoggedSqlCollector.stop()).isEmpty();
+    assertThat(LoggedSql.stop()).isEmpty();
   }
 
   @Test
   public void fetchCache_when_hitsButBeanCachePartiallyLoaded() {
-
     initDataClearCache();
 
     DB.find(Customer.class)
@@ -102,18 +98,21 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
       .select("name") // not included status in bean cache
       .findList();
 
-    customerBeanCache.getStatistics(true);
+    customerBeanCache.statistics(true);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Order> orders = DB.find(Order.class)
       .fetchCache("customer")
       .findList();
 
-    final List<String> sql0 = LoggedSqlCollector.current();
+    for (Order order : orders) {
+      assertThat(order.getCustomer().getName()).isNotNull();
+    }
+    final List<String> sql0 = LoggedSql.collect();
     assertThat(sql0).hasSize(1);
 
-    final ServerCacheStatistics statistics = customerBeanCache.getStatistics(true);
+    final ServerCacheStatistics statistics = customerBeanCache.statistics(true);
     assertThat(statistics.getHitCount()).isEqualTo(2);
 
     assertThat(trimSql(sql0.get(0))).doesNotContain("t1.status");
@@ -121,17 +120,17 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
     for (Order order : orders) {
       final Customer customer = order.getCustomer();
       assertThat(customer.getName()).isNotNull();
-      assertThat(customer.getStatus()).isNotNull(); // We hit the DB here as previously hit bean cache
+      assertThat(customer.getStatus()).isNotNull(); // We cache miss on property(status)
     }
 
-    // assert we didn't hit the L2 bean cache the second time around
-    final ServerCacheStatistics statistics1 = customerBeanCache.getStatistics(true);
-    assertThat(statistics1.getHitCount()).isEqualTo(0);
-
-    // assert we did hit the DB the second time around
-    final List<String> sql1 = LoggedSqlCollector.stop();
+    // assert we hit the DB the second time around
+    final List<String> sql1 = LoggedSql.stop();
     assertThat(sql1).hasSize(1);
     assertThat(sql1.get(0)).contains(" from o_customer t0 ");
+
+    // assert we didn't hit the L2 bean cache the second time around
+    final ServerCacheStatistics statistics1 = customerBeanCache.statistics(true);
+    assertThat(statistics1.getHitCount()).isGreaterThan(0);
   }
 
   private final FetchGroup<Order> fgBasic = FetchGroup.of(Order.class)
@@ -140,11 +139,9 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
 
   @Test
   public void fetchGroup_fetchCache() {
-
     initDataClearCache();
-
     loadCustomerBeanCache();
-    customerBeanCache.getStatistics(true);
+    customerBeanCache.statistics(true);
 
     List<Order> orders = DB.find(Order.class)
       .select(fgBasic)
@@ -152,7 +149,7 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
 
     assertThat(orders).isNotEmpty();
 
-    final ServerCacheStatistics statistics1 = customerBeanCache.getStatistics(true);
+    final ServerCacheStatistics statistics1 = customerBeanCache.statistics(true);
     assertThat(statistics1.getHitCount()).isEqualTo(2);
   }
 
@@ -160,15 +157,12 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
     .fetchCache("customer", "name")
     .build();
 
-
   @Test
   public void fetchGroup_fetchCache_partial() {
-
     initDataClearCache();
+    customerBeanCache.statistics(true);
 
-    customerBeanCache.getStatistics(true);
-
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Order> orders = DB.find(Order.class)
       .select(fgCachePartial)
@@ -176,10 +170,10 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
 
     assertThat(orders).isNotEmpty();
 
-    final ServerCacheStatistics statistics1 = customerBeanCache.getStatistics(true);
+    final ServerCacheStatistics statistics1 = customerBeanCache.statistics(true);
     assertThat(statistics1.getMissCount()).isEqualTo(2);
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains(" from o_order ");
     assertSql(sql.get(1)).contains(" from o_customer ");
@@ -187,6 +181,6 @@ public class TestBeanFetchJoinCache extends BaseTestCase {
 
   private void initDataClearCache() {
     ResetBasicData.reset();
-    server().getServerCacheManager().clearAll();
+    server().cacheManager().clearAll();
   }
 }
diff --git a/ebean-test/src/test/java/org/tests/cache/TestCacheBasic.java b/ebean-test/src/test/java/org/tests/cache/TestCacheBasic.java
new file mode 100644
index 000000000..59e54d538
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/cache/TestCacheBasic.java
@@ -0,0 +1,147 @@
+package org.tests.cache;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.cache.ServerCache;
+import io.ebean.cache.ServerCacheStatistics;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Country;
+import org.tests.model.basic.ResetBasicData;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestCacheBasic extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    DB.cacheManager().clear(Country.class);
+    ServerCache countryCache = DB.cacheManager().beanCache(Country.class);
+
+    loadCountryCache();
+    assertTrue(countryCache.size() > 0);
+
+    // reset the statistics
+    countryCache.statistics(true);
+
+    Country c0 = DB.reference(Country.class, "NZ");
+    ServerCacheStatistics statistics = countryCache.statistics(false);
+    long hc = statistics.getHitCount();
+    assertEquals(1, hc);
+    assertNotNull(c0);
+
+    // Country c1 = DB.reference(Country.class, "NZ");
+    // assertEquals(2, countryCache.getStatistics(false).getHitCount());
+    // //assertEquals(100,
+    // countryCache.getStatistics(false).getHitRatio());
+    //
+    // // same instance as caching with readOnly=true
+    // assertTrue(c0 != c1);
+    //
+    // c0.getName();
+    // c1.getName();
+    //
+    // // reset the statistics
+    // assertEquals(2,countryCache.getStatistics(true).getHitCount());
+    // // now the count should be 0 again
+    // assertEquals(0, countryCache.getStatistics(false).getHitCount());
+    // // and hitRatio is 0 as well
+    // assertEquals(0, countryCache.getStatistics(false).getHitRatio());
+    //
+    // // hit the country cache automatically via join
+    //
+    // Customer custTest = ResetBasicData.createCustAndOrder("cacheBasic");
+    // Integer id = custTest.getId();
+    // Customer customer = DB.find(Customer.class, id);
+    //
+    // Address billingAddress = customer.getBillingAddress();
+    // Country c2 = billingAddress.getCountry();
+    // c2.getName();
+    //
+    // assertTrue(countryCache.getStatistics(false).getHitCount() > 0);
+    //
+    // //Country c3 = DB.reference(Country.class, "NZ");
+    // //Country c4 = DB.find(Country.class, "NZ");
+    //
+    //
+    // // clear the cache
+    // DB.cacheManager().clear(Country.class);
+    // // reset statistics
+    // countryCache.getStatistics(true);
+    //
+    // // try to hit the country cache automatically via join
+    // customer = DB.find(Customer.class, id);
+    // billingAddress = customer.getBillingAddress();
+    // Country c5 = billingAddress.getCountry();
+    // // but cache is empty so c5 is reference that will load cache
+    // // if it is lazy loaded
+    // assertEquals("empty cache",0,countryCache.getStatistics(false).getSize());
+    // //assertEquals("missCount 1",1,countryCache.getStatistics(false).getMissCount());
+    //
+    // // lazy load on c5 populates the cache
+    // c5.getName();
+    // assertEquals("cache populated via lazy load",1,countryCache.getStatistics(false).getSize());
+    //
+    // // now these get hits in the cache
+    // Country c6 = DB.find(Country.class, "NZ");
+    //
+    // assertTrue("different instance as cache cleared",c2 != c5);
+    // assertTrue("these 2 are different",c5 != c6);
+    //
+    // // by default readOnly based on deployment annotation
+    // assertTrue("read only",DB.beanState(c6).isReadOnly());
+    //
+    // try {
+    // // can't modify a readOnly bean
+    // c6.setName("Nu Zilund");
+    // assertFalse("Never get here",true);
+    // } catch (IllegalStateException e){
+    // assertTrue("This is readOnly",true);
+    // }
+    //
+    // Country c8 = DB.find(Country.class)
+    // .setId("NZ")
+    // .setReadOnly(false)
+    // .findOne();
+    //
+    // // Explicitly NOT readOnly
+    // assertFalse("NOT read only",DB.beanState(c8).isReadOnly());
+    //
+    // assertEquals("1 countries in cache", 1, countryCache.size());
+    // c8.setName("Nu Zilund");
+    // // the update will remove the entry from the cache
+    // DB.save(c8);
+    //
+    // assertEquals("1 country in cache", 1, countryCache.size());
+    //
+    // Country c9 = DB.find(Country.class)
+    // .setReadOnly(false)
+    // .setId("NZ")
+    // .findOne();
+    //
+    // // Find loads cache ...
+    // assertFalse(DB.beanState(c9).isReadOnly());
+    // assertTrue(countryCache.size() > 0);
+    //
+    // Country c10 = DB.find(Country.class,"NZ");
+    //
+    // assertTrue(DB.beanState(c10).isReadOnly());
+    // assertTrue(countryCache.size() > 0);
+    //
+    // DB.cacheManager().clear(Country.class);
+    // assertEquals("0 country in cache", 0, countryCache.size());
+    //
+    // // reference doesn't load cache yet
+    // Country c11 = DB.reference(Country.class, "NZ");
+    //
+    // // still 0 in cache
+    // assertEquals("0 country in cache", 0, countryCache.size());
+    //
+    // // will invoke lazy loading..
+    // c11.getName();
+    // assertTrue(countryCache.size() > 0);
+
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/cache/TestCacheCollectionIds.java b/ebean-test/src/test/java/org/tests/cache/TestCacheCollectionIds.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/cache/TestCacheCollectionIds.java
rename to ebean-test/src/test/java/org/tests/cache/TestCacheCollectionIds.java
index 5cff419c4..4f22cff59 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestCacheCollectionIds.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestCacheCollectionIds.java
@@ -1,37 +1,21 @@
 package org.tests.cache;
 
-import io.ebean.BaseTestCase;
-import io.ebean.CacheMode;
-import io.ebean.Ebean;
-import io.ebean.SqlUpdate;
-import io.ebean.Transaction;
-import io.ebean.Update;
+import io.ebean.*;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheManager;
 import io.ebeaninternal.server.cache.CachedManyIds;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.tests.model.basic.Contact;
-import org.tests.model.basic.Country;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.OBeanChild;
-import org.tests.model.basic.OCachedBean;
-import org.tests.model.basic.OCachedBeanChild;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.OrderDetail;
-import org.tests.model.basic.ResetBasicData;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestCacheCollectionIds extends BaseTestCase {
 
-  private ServerCacheManager cacheManager = Ebean.getServerCacheManager();
+  private ServerCacheManager cacheManager = DB.cacheManager();
 
   @Test
   public void test() {
@@ -39,8 +23,8 @@ public class TestCacheCollectionIds extends BaseTestCase {
     ResetBasicData.reset();
     awaitL2Cache();
 
-    ServerCache custCache = cacheManager.getBeanCache(Customer.class);
-    ServerCache custManyIdsCache = cacheManager.getCollectionIdsCache(Customer.class, "contacts");
+    ServerCache custCache = cacheManager.beanCache(Customer.class);
+    ServerCache custManyIdsCache = cacheManager.collectionIdsCache(Customer.class, "contacts");
 
     // cacheManager.setCaching(Customer.class, true);
     // cacheManager.setCaching(Contact.class, true);
@@ -48,7 +32,7 @@ public class TestCacheCollectionIds extends BaseTestCase {
     custCache.clear();
     custManyIdsCache.clear();
 
-    List<Customer> list = Ebean.find(Customer.class).setAutoTune(false).setBeanCacheMode(CacheMode.PUT)
+    List<Customer> list = DB.find(Customer.class).setAutoTune(false).setBeanCacheMode(CacheMode.PUT)
       .order().asc("id").findList();
 
     assertTrue(list.size() > 1);
@@ -79,19 +63,19 @@ public class TestCacheCollectionIds extends BaseTestCase {
     Contact newContact = ResetBasicData.createContact("Check", "CollIds");
     newContact.setCustomer(customer);
 
-    Ebean.save(newContact);
+    DB.save(newContact);
     awaitL2Cache();
 
     int currentNumContacts2 = fetchCustomer(customer.getId());
     assertEquals(currentNumContacts + 1, currentNumContacts2);
 
     // cleanup
-    Ebean.delete(newContact);
+    DB.delete(newContact);
   }
 
   private int fetchCustomer(Integer id) {
 
-    Customer customer2 = Ebean.find(Customer.class, id);
+    Customer customer2 = DB.find(Customer.class, id);
 
     List<Contact> contacts2 = customer2.getContacts();
 
@@ -112,16 +96,16 @@ public class TestCacheCollectionIds extends BaseTestCase {
 
     OCachedBean cachedBean = new OCachedBean();
     cachedBean.setName("hello");
-    cachedBean.getCountries().add(Ebean.find(Country.class, "NZ"));
-    cachedBean.getCountries().add(Ebean.find(Country.class, "AU"));
+    cachedBean.getCountries().add(DB.find(Country.class, "NZ"));
+    cachedBean.getCountries().add(DB.find(Country.class, "AU"));
 
-    Ebean.save(cachedBean);
+    DB.save(cachedBean);
 
     // used to just load the cache - trigger loading
-    OCachedBean dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    OCachedBean dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     dummyToLoad.getCountries().size();
 
-    ServerCache cachedBeanCountriesCache = cacheManager.getCollectionIdsCache(OCachedBean.class, "countries");
+    ServerCache cachedBeanCountriesCache = cacheManager.collectionIdsCache(OCachedBean.class, "countries");
     CachedManyIds cachedManyIds = (CachedManyIds) cachedBeanCountriesCache.get(cachedBean.getId());
 
     // confirm the starting data and cache entry
@@ -130,15 +114,15 @@ public class TestCacheCollectionIds extends BaseTestCase {
 
 
     // act
-    OCachedBean loadedBean = Ebean.find(OCachedBean.class, cachedBean.getId());
+    OCachedBean loadedBean = DB.find(OCachedBean.class, cachedBean.getId());
     loadedBean.getCountries().clear();
-    loadedBean.getCountries().add(Ebean.find(Country.class, "AU"));
+    loadedBean.getCountries().add(DB.find(Country.class, "AU"));
 
-    Ebean.save(loadedBean);
+    DB.save(loadedBean);
     awaitL2Cache();
 
     // Get the data to assert/check against
-    OCachedBean result = Ebean.find(OCachedBean.class, cachedBean.getId());
+    OCachedBean result = DB.find(OCachedBean.class, cachedBean.getId());
     cachedManyIds = (CachedManyIds) cachedBeanCountriesCache.get(result.getId());
 
     // assert that data and cache both show correct data
@@ -155,37 +139,37 @@ public class TestCacheCollectionIds extends BaseTestCase {
     OCachedBean cachedBean = new OCachedBean();
     cachedBean.setName("hello1");
 
-    Ebean.save(cachedBean);
+    DB.save(cachedBean);
     awaitL2Cache();
 
-    OCachedBean dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    OCachedBean dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(0, dummyToLoad.getChildren().size());
 
     OCachedBeanChild child1=new OCachedBeanChild();
     child1.setCachedBean(cachedBean);
-    Ebean.insert(child1);
+    DB.insert(child1);
     awaitL2Cache();
-    dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(1, dummyToLoad.getChildren().size());
 
     OCachedBeanChild child2=new OCachedBeanChild();
     child2.setCachedBean(cachedBean);
-    Ebean.insert(child2);
+    DB.insert(child2);
     awaitL2Cache();
-    dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(2, dummyToLoad.getChildren().size());
 
-    Ebean.delete(child2);
+    DB.delete(child2);
     awaitL2Cache();
-    dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(1, dummyToLoad.getChildren().size());
 
-    Ebean.delete(child1);
+    DB.delete(child1);
     awaitL2Cache();
-    dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(0, dummyToLoad.getChildren().size());
 
-    Ebean.delete(cachedBean);
+    DB.delete(cachedBean);
   }
 
   @Test
@@ -195,37 +179,37 @@ public class TestCacheCollectionIds extends BaseTestCase {
     OCachedBean cachedBean = new OCachedBean();
     cachedBean.setName("hello2");
 
-    Ebean.save(cachedBean);
+    DB.save(cachedBean);
     awaitL2Cache();
 
-    OCachedBean dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    OCachedBean dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(0, dummyToLoad.getNotCachedChildren().size());
 
     OBeanChild child1=new OBeanChild();
     child1.setCachedBean(cachedBean);
-    Ebean.insert(child1);
+    DB.insert(child1);
     awaitL2Cache();
-    dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(1, dummyToLoad.getNotCachedChildren().size());
 
     OBeanChild child2=new OBeanChild();
     child2.setCachedBean(cachedBean);
-    Ebean.insert(child2);
+    DB.insert(child2);
     awaitL2Cache();
-    dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(2, dummyToLoad.getNotCachedChildren().size());
 
-    Ebean.delete(child2);
+    DB.delete(child2);
     awaitL2Cache();
-    dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(1, dummyToLoad.getNotCachedChildren().size());
 
-    Ebean.delete(child1);
+    DB.delete(child1);
     awaitL2Cache();
-    dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(0, dummyToLoad.getNotCachedChildren().size());
 
-    Ebean.delete(cachedBean);
+    DB.delete(cachedBean);
   }
 
 
@@ -240,16 +224,16 @@ public class TestCacheCollectionIds extends BaseTestCase {
 
     OCachedBean cachedBean = new OCachedBean();
     cachedBean.setName("hello");
-    cachedBean.getCountries().add(Ebean.find(Country.class, "NZ"));
-    cachedBean.getCountries().add(Ebean.find(Country.class, "AU"));
+    cachedBean.getCountries().add(DB.find(Country.class, "NZ"));
+    cachedBean.getCountries().add(DB.find(Country.class, "AU"));
 
-    Ebean.save(cachedBean);
+    DB.save(cachedBean);
 
     // used to just load the cache - trigger loading
-    OCachedBean dummyToLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    OCachedBean dummyToLoad = DB.find(OCachedBean.class, cachedBean.getId());
     dummyToLoad.getCountries().size();
 
-    ServerCache cachedBeanCountriesCache = cacheManager.getCollectionIdsCache(OCachedBean.class, "countries");
+    ServerCache cachedBeanCountriesCache = cacheManager.collectionIdsCache(OCachedBean.class, "countries");
     CachedManyIds cachedManyIds = (CachedManyIds) cachedBeanCountriesCache.get(cachedBean.getId());
 
     // confirm the starting data and cache entry
@@ -258,16 +242,16 @@ public class TestCacheCollectionIds extends BaseTestCase {
 
 
     // act - this time update the name property so the bean is dirty
-    OCachedBean loadedBean = Ebean.find(OCachedBean.class, cachedBean.getId());
+    OCachedBean loadedBean = DB.find(OCachedBean.class, cachedBean.getId());
     loadedBean.setName("goodbye");
     loadedBean.getCountries().clear();
-    loadedBean.getCountries().add(Ebean.find(Country.class, "AU"));
+    loadedBean.getCountries().add(DB.find(Country.class, "AU"));
 
-    Ebean.save(loadedBean);
+    DB.save(loadedBean);
     awaitL2Cache();
 
     // Get the data to assert/check against
-    OCachedBean result = Ebean.find(OCachedBean.class, cachedBean.getId());
+    OCachedBean result = DB.find(OCachedBean.class, cachedBean.getId());
     cachedManyIds = (CachedManyIds) cachedBeanCountriesCache.get(result.getId());
 
     // assert that data and cache both show correct data
@@ -287,26 +271,26 @@ public class TestCacheCollectionIds extends BaseTestCase {
 
     OCachedBean cachedBean = new OCachedBean();
     cachedBean.setName("cachedBeanTest");
-    cachedBean.getCountries().add(Ebean.find(Country.class, "NZ"));
-    cachedBean.getCountries().add(Ebean.find(Country.class, "AU"));
+    cachedBean.getCountries().add(DB.find(Country.class, "NZ"));
+    cachedBean.getCountries().add(DB.find(Country.class, "AU"));
 
-    Ebean.save(cachedBean);
+    DB.save(cachedBean);
 
     // clear the cache
-    ServerCache cachedBeanCountriesCache = cacheManager.getCollectionIdsCache(OCachedBean.class, "countries");
+    ServerCache cachedBeanCountriesCache = cacheManager.collectionIdsCache(OCachedBean.class, "countries");
     cachedBeanCountriesCache.clear();
     assertEquals(0, cachedBeanCountriesCache.size());
 
     // load the cache
-    OCachedBean dummyLoad = Ebean.find(OCachedBean.class, cachedBean.getId());
+    OCachedBean dummyLoad = DB.find(OCachedBean.class, cachedBean.getId());
     List<Country> dummyCountries = dummyLoad.getCountries();
     assertEquals(2, dummyCountries.size());
 
     // assert that the cache contains the expected entry
-    assertEquals("countries cache now loaded with 1 entry", 1, cachedBeanCountriesCache.size());
+    assertEquals(1, cachedBeanCountriesCache.size());
     CachedManyIds dummyEntry = (CachedManyIds) cachedBeanCountriesCache.get(dummyLoad.getId());
     assertNotNull(dummyEntry);
-    assertEquals("2 ids in the entry", 2, dummyEntry.getIdList().size());
+    assertEquals(2, dummyEntry.getIdList().size());
     assertTrue(dummyEntry.getIdList().contains("NZ"));
     assertTrue(dummyEntry.getIdList().contains("AU"));
 
@@ -315,12 +299,12 @@ public class TestCacheCollectionIds extends BaseTestCase {
     OCachedBean update = new OCachedBean();
     update.setId(cachedBean.getId());
     update.setName("modified");
-    update.getCountries().add(Ebean.find(Country.class, "AU"));
+    update.getCountries().add(DB.find(Country.class, "AU"));
 
-    Ebean.update(update);
+    DB.update(update);
     awaitL2Cache();
 
-    assertEquals("countries entry still there (but updated)", 1, cachedBeanCountriesCache.size());
+    assertEquals(1, cachedBeanCountriesCache.size());
 
     CachedManyIds cachedManyIds = (CachedManyIds) cachedBeanCountriesCache.get(update.getId());
 
@@ -330,7 +314,7 @@ public class TestCacheCollectionIds extends BaseTestCase {
     assertTrue(cachedManyIds.getIdList().contains("AU"));
 
     // assert countries good
-    OCachedBean result = Ebean.find(OCachedBean.class, cachedBean.getId());
+    OCachedBean result = DB.find(OCachedBean.class, cachedBean.getId());
     assertEquals(1, result.getCountries().size());
 
   }
@@ -340,23 +324,23 @@ public class TestCacheCollectionIds extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    try (Transaction txn = Ebean.beginTransaction()) {
+    try (Transaction txn = DB.beginTransaction()) {
 
       OCachedBean cachedBean = new OCachedBean();
       cachedBean.setName("helloForUpdate");
-      Ebean.save(cachedBean);
+      DB.save(cachedBean);
 
-      cachedBean = Ebean.find(OCachedBean.class, cachedBean.getId());
+      cachedBean = DB.find(OCachedBean.class, cachedBean.getId());
 
       cachedBean.setName("mod");
       ArrayList<Country> list = new ArrayList<>();
-      list.add(Ebean.find(Country.class, "NZ"));
+      list.add(DB.find(Country.class, "NZ"));
       cachedBean.setCountries(list);
-      Ebean.save(cachedBean);
+      DB.save(cachedBean);
 
 
       cachedBean.setName("mod2");
-      Ebean.save(cachedBean);
+      DB.save(cachedBean);
 
       txn.commit();
     }
@@ -369,13 +353,13 @@ public class TestCacheCollectionIds extends BaseTestCase {
    * When doing an ORM update the collection cache must be cleared.
    */
   @Test
-  @Ignore
+  @Disabled
   public void testClearingCollectionCacheOnORMUpdate() {
     // arrange
     ResetBasicData.reset();
 
     // load the cache with the order
-    Order order1 = Ebean.find(Order.class, 1L);
+    Order order1 = DB.find(Order.class, 1L);
 
     // load the Collection IDs (order.orderDetail) cache
     OrderDetail orderDetail1 = order1.getDetails().get(0);
@@ -383,13 +367,13 @@ public class TestCacheCollectionIds extends BaseTestCase {
     // delete one order detail from DB. This triggers clearing of OrderDetail caches
     // and should also clear any Collection IDs caches targeting OrderDetail bean
     String updStatement = "delete from orderDetail where id = :id";
-    Update<OrderDetail> update = Ebean.createUpdate(OrderDetail.class, updStatement);
+    Update<OrderDetail> update = DB.createUpdate(OrderDetail.class, updStatement);
     update.set("id", orderDetail1.getId());
     int rows = update.execute();
     assertEquals(1, rows);
 
     // read the order from cache
-    Order orderFromCache = Ebean.find(Order.class, 1L);
+    Order orderFromCache = DB.find(Order.class, 1L);
     OrderDetail orderDetailFromCache = orderFromCache.getDetails().get(0);
 
     // trigger reading from the DB
@@ -404,13 +388,13 @@ public class TestCacheCollectionIds extends BaseTestCase {
    * This is true for all changes insert,update, delete. Tested for delete here.
    */
   @Test
-  @Ignore
+  @Disabled
   public void testClearingCollectionCacheOnExternalModification() {
     // arrange
     ResetBasicData.reset();
 
     // load the cache with the order
-    Order order1 = Ebean.find(Order.class, 1L);
+    Order order1 = DB.find(Order.class, 1L);
 
     // load the Collection IDs (order.orderDetail) cache
     OrderDetail orderDetail1 = order1.getDetails().get(0);
@@ -418,16 +402,16 @@ public class TestCacheCollectionIds extends BaseTestCase {
     // delete one order detail from DB using native SQL. This triggers clearing of OrderDetail caches
     // and should also clear any Collection IDs caches targeting OrderDetail bean
     String updStatement = "delete from o_order_detail where id = :id";
-    SqlUpdate update = Ebean.createSqlUpdate(updStatement);
+    SqlUpdate update = DB.sqlUpdate(updStatement);
     update.setParameter("id", orderDetail1.getId());
     int rows = update.execute();
     assertEquals(1, rows);
 
     // We need to notify the cache manually
-    Ebean.externalModification("o_order_detail", false, false, true);
+    DB.externalModification("o_order_detail", false, false, true);
 
     // read the order from cache
-    Order orderFromCache = Ebean.find(Order.class, 1L);
+    Order orderFromCache = DB.find(Order.class, 1L);
     OrderDetail orderDetailFromCache = orderFromCache.getDetails().get(0);
 
     // trigger reading the whole bean
diff --git a/ebean-core/src/test/java/org/tests/cache/TestCacheCustomer.java b/ebean-test/src/test/java/org/tests/cache/TestCacheCustomer.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/cache/TestCacheCustomer.java
rename to ebean-test/src/test/java/org/tests/cache/TestCacheCustomer.java
index 68a91678c..829d07279 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestCacheCustomer.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestCacheCustomer.java
@@ -2,17 +2,14 @@ package org.tests.cache;
 
 import io.ebean.BaseTestCase;
 import io.ebean.CacheMode;
-import io.ebean.Ebean;
-import org.junit.Assert;
-import org.junit.Test;
-import org.tests.model.basic.Address;
-import org.tests.model.basic.Contact;
-import org.tests.model.basic.Country;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.ResetBasicData;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestCacheCustomer extends BaseTestCase {
 
   @Test
@@ -20,18 +17,18 @@ public class TestCacheCustomer extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Country nz = Ebean.getReference(Country.class, "NZ");
+    Country nz = DB.reference(Country.class, "NZ");
     Address address = new Address();
     address.setLine1("Some Place");
     address.setCity("Auckland");
     address.setCountry(nz);
 
-    Ebean.save(address);
+    DB.save(address);
 
     address.setLine2("Else");
-    Ebean.save(address);
+    DB.save(address);
 
-    Ebean.delete(address);
+    DB.delete(address);
   }
 
   @Test
@@ -39,10 +36,10 @@ public class TestCacheCustomer extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class).setAutoTune(false).setBeanCacheMode(CacheMode.PUT)
+    List<Customer> list = DB.find(Customer.class).setAutoTune(false).setBeanCacheMode(CacheMode.PUT)
       .findList();
 
-    Assert.assertTrue(list.size() > 1);
+    assertTrue(list.size() > 1);
 
     for (Customer customer : list) {
       Address billingAddress = customer.getBillingAddress();
diff --git a/ebean-core/src/test/java/org/tests/cache/TestCacheDelete.java b/ebean-test/src/test/java/org/tests/cache/TestCacheDelete.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/cache/TestCacheDelete.java
rename to ebean-test/src/test/java/org/tests/cache/TestCacheDelete.java
index a5f5e111e..02c220f3b 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestCacheDelete.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestCacheDelete.java
@@ -1,12 +1,12 @@
 package org.tests.cache;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.OCachedBean;
 import org.tests.model.basic.OCachedBeanChild;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * Test class testing deleting/invalidating of cached beans
@@ -25,21 +25,21 @@ public class TestCacheDelete extends BaseTestCase {
     OCachedBean parentBean = new OCachedBean();
     parentBean.getChildren().add(child);
     parentBean.getChildren().add(child2);
-    Ebean.save(parentBean);
+    DB.save(parentBean);
 
     // confirm there are 2 children loaded from the parent
-    assertEquals(2, Ebean.find(OCachedBean.class, parentBean.getId()).getChildren().size());
+    assertEquals(2, DB.find(OCachedBean.class, parentBean.getId()).getChildren().size());
 
     // ensure cache has been populated
-    Ebean.find(OCachedBeanChild.class, child.getId());
-    child2 = Ebean.find(OCachedBeanChild.class, child2.getId());
-    parentBean = Ebean.find(OCachedBean.class, parentBean.getId());
+    DB.find(OCachedBeanChild.class, child.getId());
+    child2 = DB.find(OCachedBeanChild.class, child2.getId());
+    parentBean = DB.find(OCachedBean.class, parentBean.getId());
 
     // act
-    Ebean.delete(child2);
+    DB.delete(child2);
     awaitL2Cache();
 
-    OCachedBean beanFromCache = Ebean.find(OCachedBean.class, parentBean.getId());
+    OCachedBean beanFromCache = DB.find(OCachedBean.class, parentBean.getId());
     assertEquals(1, beanFromCache.getChildren().size());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/cache/TestCacheEmbeddedId.java b/ebean-test/src/test/java/org/tests/cache/TestCacheEmbeddedId.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/cache/TestCacheEmbeddedId.java
rename to ebean-test/src/test/java/org/tests/cache/TestCacheEmbeddedId.java
index ccc65f820..ce511ea58 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestCacheEmbeddedId.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestCacheEmbeddedId.java
@@ -2,11 +2,11 @@ package org.tests.cache;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.CKeyParent;
 import org.tests.model.basic.CKeyParentId;
 
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestCacheEmbeddedId extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/cache/TestCacheInterceptSaveWhenLazyLoaded.java b/ebean-test/src/test/java/org/tests/cache/TestCacheInterceptSaveWhenLazyLoaded.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/cache/TestCacheInterceptSaveWhenLazyLoaded.java
rename to ebean-test/src/test/java/org/tests/cache/TestCacheInterceptSaveWhenLazyLoaded.java
index 992d3eabc..a71f52130 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestCacheInterceptSaveWhenLazyLoaded.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestCacheInterceptSaveWhenLazyLoaded.java
@@ -1,14 +1,14 @@
 package org.tests.cache;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestCacheInterceptSaveWhenLazyLoaded extends BaseTestCase {
 
@@ -19,24 +19,24 @@ public class TestCacheInterceptSaveWhenLazyLoaded extends BaseTestCase {
 
     Customer customer = new Customer();
     customer.setName("daCustomer");
-    Ebean.save(customer);
+    DB.save(customer);
 
     Order order = new Order();
     order.setStatus(Order.Status.NEW);
     order.setCustomer(customer);
-    Ebean.save(order);
+    DB.save(order);
 
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
 
-      Order foundOrder = Ebean.find(Order.class)
+      Order foundOrder = DB.find(Order.class)
         .where().eq("id", order.getId())
         .findOne();
 
       foundOrder.setStatus(Order.Status.APPROVED);
-      assertTrue(Ebean.getBeanState(foundOrder).isDirty());
+      assertTrue(DB.beanState(foundOrder).isDirty());
 
-      Customer foundCustomer = Ebean.find(Customer.class)
+      Customer foundCustomer = DB.find(Customer.class)
         .where().eq("id", customer.getId())
         .findOne();
 
@@ -46,14 +46,14 @@ public class TestCacheInterceptSaveWhenLazyLoaded extends BaseTestCase {
       Order order1 = foundCustomer.getOrders().get(0);
 
       assertSame(foundOrder, order1);
-      assertTrue(Ebean.getBeanState(foundOrder).isDirty());
+      assertTrue(DB.beanState(foundOrder).isDirty());
 
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
 
     // cleanup
-    Ebean.delete(order);
-    Ebean.delete(customer);
+    DB.delete(order);
+    DB.delete(customer);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/cache/TestCacheManyToOne.java b/ebean-test/src/test/java/org/tests/cache/TestCacheManyToOne.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/cache/TestCacheManyToOne.java
rename to ebean-test/src/test/java/org/tests/cache/TestCacheManyToOne.java
index fd6e209b0..225a7ac38 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestCacheManyToOne.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestCacheManyToOne.java
@@ -1,13 +1,13 @@
 package org.tests.cache;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.OCachedInhChildA;
 import org.tests.model.basic.OCachedInhRoot;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 /**
  * Test class testing deleting/invalidating of cached beans
@@ -20,15 +20,15 @@ public class TestCacheManyToOne extends BaseTestCase {
     OCachedInhChildA bean = new OCachedInhChildA();
     bean.setName("Roland");
     bean.setChildAData("ChildData");
-    Ebean.save(bean);
+    DB.save(bean);
 
-    Ebean.find(OCachedInhRoot.class).select("id").where().idIn(bean.getId()).findEach(bean0 -> {
+    DB.find(OCachedInhRoot.class).select("id").where().idIn(bean.getId()).findEach(bean0 -> {
       assertNotNull(bean0);
       assertThat(bean0.getName()).isEqualTo("Roland");
       assertThat(((OCachedInhChildA)bean0).getChildAData()).isEqualTo("ChildData");
     });
 
-    Ebean.find(OCachedInhRoot.class).select("id").where().idIn(bean.getId()).findEach(bean1 -> {
+    DB.find(OCachedInhRoot.class).select("id").where().idIn(bean.getId()).findEach(bean1 -> {
       assertNotNull(bean1);
       assertThat(bean1.getName()).isEqualTo("Roland");
       // this will fail if the bean is loaded from cache and the wrong discriminator is used.
diff --git a/ebean-core/src/test/java/org/tests/cache/TestCacheNaturalId.java b/ebean-test/src/test/java/org/tests/cache/TestCacheNaturalId.java
similarity index 52%
rename from ebean-core/src/test/java/org/tests/cache/TestCacheNaturalId.java
rename to ebean-test/src/test/java/org/tests/cache/TestCacheNaturalId.java
index 8e64c2327..1da96116a 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestCacheNaturalId.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestCacheNaturalId.java
@@ -2,18 +2,16 @@ package org.tests.cache;
 
 import io.ebean.BaseTestCase;
 import io.ebean.CacheMode;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheStatistics;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestCacheNaturalId extends BaseTestCase {
 
@@ -22,9 +20,9 @@ public class TestCacheNaturalId extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    ServerCache contactCache = Ebean.getServerCacheManager().getBeanCache(Contact.class);
+    ServerCache contactCache = DB.cacheManager().beanCache(Contact.class);
 
-    List<Contact> list = Ebean.find(Contact.class).setBeanCacheMode(CacheMode.PUT).findList();
+    List<Contact> list = DB.find(Contact.class).setBeanCacheMode(CacheMode.PUT).findList();
 
     assertTrue(contactCache.size() > 0);
 
@@ -36,15 +34,15 @@ public class TestCacheNaturalId extends BaseTestCase {
       }
     }
 
-    contactCache.getStatistics(true);
+    contactCache.statistics(true);
 
-    Contact c0 = Ebean.find(Contact.class).where().eq("email", emailToSearch).findOne();
+    Contact c0 = DB.find(Contact.class).where().eq("email", emailToSearch).findOne();
 
-    ServerCacheStatistics stats0 = contactCache.getStatistics(false);
+    ServerCacheStatistics stats0 = contactCache.statistics(false);
 
-    Contact c1 = Ebean.find(Contact.class).where().eq("email", emailToSearch).findOne();
+    Contact c1 = DB.find(Contact.class).where().eq("email", emailToSearch).findOne();
 
-    ServerCacheStatistics stats1 = contactCache.getStatistics(false);
+    ServerCacheStatistics stats1 = contactCache.statistics(false);
 
     assertNotNull(c0);
     assertNotNull(c1);
@@ -53,13 +51,13 @@ public class TestCacheNaturalId extends BaseTestCase {
     assertEquals(2, stats1.getHitCount());
 
     c1.setEmail("mychangedemail@what.com");
-    Ebean.save(c1);
+    DB.save(c1);
     awaitL2Cache();
 
-    Contact c2 = Ebean.find(Contact.class).where().eq("email", "mychangedemail@what.com")
+    Contact c2 = DB.find(Contact.class).where().eq("email", "mychangedemail@what.com")
       .findOne();
 
-    ServerCacheStatistics stats2 = contactCache.getStatistics(false);
+    ServerCacheStatistics stats2 = contactCache.statistics(false);
 
     assertNotNull(c2);
     assertEquals(c2.getId(), c1.getId());
diff --git a/ebean-core/src/test/java/org/tests/cache/TestExternalNotification.java b/ebean-test/src/test/java/org/tests/cache/TestExternalNotification.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/cache/TestExternalNotification.java
rename to ebean-test/src/test/java/org/tests/cache/TestExternalNotification.java
index b55135f30..a6a52c38b 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestExternalNotification.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestExternalNotification.java
@@ -1,16 +1,16 @@
 package org.tests.cache;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.SqlUpdate;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheManager;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestExternalNotification extends BaseTestCase {
 
@@ -21,44 +21,43 @@ public class TestExternalNotification extends BaseTestCase {
 
     loadCountryCache();
 
-    ServerCache countryCache = Ebean.getServerCacheManager().getBeanCache(Country.class);
+    ServerCache countryCache = DB.cacheManager().beanCache(Country.class);
 
     assertTrue(countryCache.size() > 0);
 
     // inserts don't remove from bean cache
-    Ebean.externalModification("o_country", true, false, false);
+    DB.externalModification("o_country", true, false, false);
     assertTrue(countryCache.size() > 0);
 
     // updates flush cache
-    Ebean.externalModification("o_country", false, true, false);
+    DB.externalModification("o_country", false, true, false);
     assertEquals(0, countryCache.size());
 
     loadCountryCache();
     assertTrue(countryCache.size() > 0);
 
     // deletes flush cache
-    Ebean.externalModification("o_country", false, false, true);
+    DB.externalModification("o_country", false, false, true);
     assertEquals(0, countryCache.size());
 
     loadCountryCache();
     assertTrue(countryCache.size() > 0);
 
-    ServerCacheManager serverCacheManager = Ebean.getServerCacheManager();
+    ServerCacheManager serverCacheManager = DB.cacheManager();
     serverCacheManager.clearAll();
     assertEquals(0, countryCache.size());
 
     loadCountryCache();
     assertTrue(countryCache.size() > 0);
 
-    Ebean.getServerCacheManager().clear(Country.class);
+    DB.cacheManager().clear(Country.class);
     assertEquals(0, countryCache.size());
 
     loadCountryCache();
     int cacheSize = countryCache.size();
-    assertTrue("cacheSize: " + cacheSize, cacheSize > 0);
+    assertTrue(cacheSize > 0);
 
-    SqlUpdate sqlUpdate = Ebean
-      .createSqlUpdate("update o_country set name = :name where code = :code");
+    SqlUpdate sqlUpdate = DB.sqlUpdate("update o_country set name = :name where code = :code");
     sqlUpdate.setParameter("name", "Aotearoa");
     sqlUpdate.setParameter("code", "NZ");
 
diff --git a/ebean-core/src/test/java/org/tests/cache/TestL2CacheWithSharedBean.java b/ebean-test/src/test/java/org/tests/cache/TestL2CacheWithSharedBean.java
similarity index 61%
rename from ebean-core/src/test/java/org/tests/cache/TestL2CacheWithSharedBean.java
rename to ebean-test/src/test/java/org/tests/cache/TestL2CacheWithSharedBean.java
index cbc736cc5..0655ae4c4 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestL2CacheWithSharedBean.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestL2CacheWithSharedBean.java
@@ -1,15 +1,14 @@
 package org.tests.cache;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.cache.ServerCache;
 import io.ebeaninternal.server.querydefn.OrmQueryDetail;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.FeatureDescription;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestL2CacheWithSharedBean extends BaseTestCase {
 
@@ -26,16 +25,16 @@ public class TestL2CacheWithSharedBean extends BaseTestCase {
     f1.setName("one");
     f1.setDescription("helloOne");
 
-    Ebean.save(f1);
+    DB.save(f1);
 
-    ServerCache beanCache = Ebean.getServerCacheManager().getBeanCache(FeatureDescription.class);
-    beanCache.getStatistics(true);
+    ServerCache beanCache = DB.cacheManager().beanCache(FeatureDescription.class);
+    beanCache.statistics(true);
 
     OrmQueryDetail tunedDetail = new OrmQueryDetail();
     tunedDetail.select("name");
 //    TunedQueryInfo tunedInfo = createTunedQueryInfo(tunedDetail);
 
-    Query<FeatureDescription> query = Ebean.find(FeatureDescription.class).setId(f1.getId());
+    Query<FeatureDescription> query = DB.find(FeatureDescription.class).setId(f1.getId());
 
 //    tunedInfo.tuneQuery((SpiQuery<?>) query);
 
@@ -47,13 +46,13 @@ public class TestL2CacheWithSharedBean extends BaseTestCase {
     assertEquals("helloOne", description0);
 
     // load the cache
-    FeatureDescription fetchOne = Ebean.find(FeatureDescription.class, f1.getId());
-    Assert.assertNotNull(fetchOne);
-    assertEquals(1, beanCache.getStatistics(false).getSize());
+    FeatureDescription fetchOne = DB.find(FeatureDescription.class, f1.getId());
+    assertNotNull(fetchOne);
+    assertEquals(1, beanCache.statistics(false).getSize());
 
-    FeatureDescription fetchTwo = Ebean.find(FeatureDescription.class, f1.getId());
-    FeatureDescription fetchThree = Ebean.find(FeatureDescription.class, f1.getId());
-    Assert.assertSame(fetchTwo, fetchThree);
+    FeatureDescription fetchTwo = DB.find(FeatureDescription.class, f1.getId());
+    FeatureDescription fetchThree = DB.find(FeatureDescription.class, f1.getId());
+    assertSame(fetchTwo, fetchThree);
 
     String description1 = fetchThree.getDescription();
     assertEquals("helloOne", description1);
diff --git a/ebean-core/src/test/java/org/tests/cache/TestL2DirtyFlagOnLazyLoad.java b/ebean-test/src/test/java/org/tests/cache/TestL2DirtyFlagOnLazyLoad.java
similarity index 57%
rename from ebean-core/src/test/java/org/tests/cache/TestL2DirtyFlagOnLazyLoad.java
rename to ebean-test/src/test/java/org/tests/cache/TestL2DirtyFlagOnLazyLoad.java
index bd655c2fd..c65383dc0 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestL2DirtyFlagOnLazyLoad.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestL2DirtyFlagOnLazyLoad.java
@@ -2,15 +2,13 @@ package org.tests.cache;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.L2CachedLazyDirtFlagResetBean;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestL2DirtyFlagOnLazyLoad extends BaseTestCase {
 
@@ -18,46 +16,46 @@ public class TestL2DirtyFlagOnLazyLoad extends BaseTestCase {
   public void dirtyFlag_reset_after_lazy() {
     L2CachedLazyDirtFlagResetBean bean = new L2CachedLazyDirtFlagResetBean();
     //PREPARE
-    try (Transaction tx0 = Ebean.beginTransaction()) {
+    try (Transaction tx0 = DB.beginTransaction()) {
       bean.setName("findById");
-      Ebean.save(bean);
+      DB.save(bean);
       //bean.save();
       tx0.commit();
     }
 
     // clearAll() caches via the ServerCacheManager ...
     // Clear all the caches on the default/primary EbeanServer
-    server().getServerCacheManager().clearAll();
+    server().cacheManager().clearAll();
 
     //TEST
-    try (Transaction tx1 = Ebean.beginTransaction()) {
+    try (Transaction tx1 = DB.beginTransaction()) {
       // load (and dont touch any related entity)
-      L2CachedLazyDirtFlagResetBean bean1 = Ebean.find(L2CachedLazyDirtFlagResetBean.class, bean.getId());
+      L2CachedLazyDirtFlagResetBean bean1 = DB.find(L2CachedLazyDirtFlagResetBean.class, bean.getId());
       assertThat(bean1).isNotNull();
       tx1.commit();
     }
 
-    try (Transaction tx2 = Ebean.beginTransaction()) {
+    try (Transaction tx2 = DB.beginTransaction()) {
       // load (and modify)
 
-      L2CachedLazyDirtFlagResetBean bean2 = Ebean.find(L2CachedLazyDirtFlagResetBean.class, bean.getId());
+      L2CachedLazyDirtFlagResetBean bean2 = DB.find(L2CachedLazyDirtFlagResetBean.class, bean.getId());
       assertNotNull(bean2);
       assertEquals("findById", bean2.getName());
       bean2.setName("something");
-      BeanState beanState = Ebean.getBeanState(bean2);
+      BeanState beanState = DB.beanState(bean2);
       assertTrue(beanState.isDirty());
       //bean2.getChildren().size();
       bean2.someRichObjectMethod();
       assertTrue(beanState.isDirty());
 
-      Ebean.update(bean2);
+      DB.update(bean2);
       tx2.commit();
     }
 
-    try(Transaction tx3 = Ebean.beginTransaction()) {
+    try(Transaction tx3 = DB.beginTransaction()) {
       // validation
 
-      L2CachedLazyDirtFlagResetBean bean3 = Ebean.find(L2CachedLazyDirtFlagResetBean.class, bean.getId());
+      L2CachedLazyDirtFlagResetBean bean3 = DB.find(L2CachedLazyDirtFlagResetBean.class, bean.getId());
       assertEquals("something", bean3.getName());
 
     }
diff --git a/ebean-core/src/test/java/org/tests/cache/TestM2MCache.java b/ebean-test/src/test/java/org/tests/cache/TestM2MCache.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/cache/TestM2MCache.java
rename to ebean-test/src/test/java/org/tests/cache/TestM2MCache.java
index 83cb402f1..fdeb6f30d 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestM2MCache.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestM2MCache.java
@@ -1,13 +1,12 @@
 package org.tests.cache;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
-import org.junit.Test;
-import org.tests.model.cache.M2MCacheChild;
-import org.tests.model.cache.M2MCacheMaster;
-
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.cache.M2MCacheChild;
+import org.tests.model.cache.M2MCacheMaster;
+
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestM2MCache extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/cache/TestQueryCache.java b/ebean-test/src/test/java/org/tests/cache/TestQueryCache.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/cache/TestQueryCache.java
rename to ebean-test/src/test/java/org/tests/cache/TestQueryCache.java
index 4c4d56109..f70bc44c7 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestQueryCache.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestQueryCache.java
@@ -6,9 +6,8 @@ import io.ebean.DB;
 import io.ebean.ExpressionList;
 import io.ebean.bean.BeanCollection;
 import io.ebean.cache.ServerCache;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 import org.tests.model.cache.EColAB;
@@ -17,6 +16,7 @@ import java.util.List;
 import java.util.function.Consumer;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryCache extends BaseTestCase {
 
@@ -104,7 +104,7 @@ public class TestQueryCache extends BaseTestCase {
     new EColAB("04", "count").save();
     new EColAB("05", "count").save();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     int count0 = DB.find(EColAB.class)
       .setUseQueryCache(CacheMode.ON)
@@ -118,20 +118,20 @@ public class TestQueryCache extends BaseTestCase {
       .eq("columnB", "count")
       .findCount();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(count0).isEqualTo(count1);
     assertThat(sql).hasSize(1);
 
     // and now, ensure that we hit the database
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     int count2 = DB.find(EColAB.class)
         .setUseQueryCache(CacheMode.OFF)
         .where()
         .eq("columnB", "count")
         .findCount();
     assertThat(count2).isEqualTo(count1);
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
   }
 
@@ -139,7 +139,7 @@ public class TestQueryCache extends BaseTestCase {
   public void findCountDifferentQueries() {
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     int count0 = DB.find(EColAB.class)
       .setUseQueryCache(CacheMode.ON)
@@ -153,7 +153,7 @@ public class TestQueryCache extends BaseTestCase {
       .eq("columnB", "def")
       .findCount();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(count0).isEqualTo(count1);
     assertThat(sql).hasSize(2); // different queries
@@ -164,7 +164,7 @@ public class TestQueryCache extends BaseTestCase {
   public void findCountFirstOnThenRecache() {
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     int count0 = DB.find(EColAB.class)
       .setUseQueryCache(CacheMode.ON)
@@ -178,7 +178,7 @@ public class TestQueryCache extends BaseTestCase {
       .eq("columnB", "uvw")
       .findCount();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(count0).isEqualTo(count1);
     assertThat(sql).hasSize(2); // try recache as second query - it must fetch it
@@ -190,7 +190,7 @@ public class TestQueryCache extends BaseTestCase {
   public void findCountFirstRecacheThenOn() {
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     int count0 = DB.find(EColAB.class)
       .setUseQueryCache(CacheMode.PUT)
@@ -204,7 +204,7 @@ public class TestQueryCache extends BaseTestCase {
       .eq("columnB", "xyz")
       .findCount();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(count0).isEqualTo(count1);
     assertThat(sql).hasSize(1); // try recache as first query - second "ON" query must fetch it.
@@ -217,17 +217,17 @@ public class TestQueryCache extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    ServerCache customerCache = DB.getServerCacheManager().getQueryCache(Customer.class);
+    ServerCache customerCache = DB.cacheManager().queryCache(Customer.class);
     customerCache.clear();
 
     List<Customer> list = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true).where()
       .ilike("name", "Rob").findList();
 
     BeanCollection<Customer> bc = (BeanCollection<Customer>) list;
-    Assert.assertTrue(bc.isReadOnly());
-    Assert.assertFalse(bc.isEmpty());
-    Assert.assertTrue(!list.isEmpty());
-    Assert.assertTrue(DB.getBeanState(list.get(0)).isReadOnly());
+    assertTrue(bc.isReadOnly());
+    assertFalse(bc.isEmpty());
+    assertTrue(!list.isEmpty());
+    assertTrue(DB.beanState(list.get(0)).isReadOnly());
 
     List<Customer> list2 = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true).where()
       .ilike("name", "Rob").findList();
@@ -236,25 +236,22 @@ public class TestQueryCache extends BaseTestCase {
       // .setReadOnly(true)
       .where().ilike("name", "Rob").findList();
 
-    Assert.assertSame(list, list2);
+    assertSame(list, list2);
 
     // readOnly defaults to true for query cache
-    Assert.assertSame(list, list2B);
-
-
-
+    assertSame(list, list2B);
 
     List<Customer> list3 = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(false).where()
         .ilike("name", "Rob").findList();
 
-    Assert.assertNotSame(list, list3);
+    assertNotSame(list, list3);
     BeanCollection<Customer> bc3 = (BeanCollection<Customer>) list3;
-    Assert.assertFalse(bc3.isReadOnly());
-    Assert.assertFalse(bc3.isEmpty());
-    Assert.assertTrue(list3.size() > 0);
+    assertFalse(bc3.isReadOnly());
+    assertFalse(bc3.isEmpty());
+    assertTrue(list3.size() > 0);
     // TODO: At this stage setReadOnly(false) does create a shallow copy of the List/Set/Map, but does not
     // change the read only state in the entities.
-    // Assert.assertFalse(Ebean.getBeanState(list3.get(0)).isReadOnly());
+    // assertFalse(DB.beanState(list3.get(0)).isReadOnly());
 
   }
 
@@ -266,7 +263,7 @@ public class TestQueryCache extends BaseTestCase {
     new EColAB("04", "someId").save();
     new EColAB("05", "someId").save();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Integer> colA_first = DB.find(EColAB.class)
       .setUseQueryCache(CacheMode.ON)
@@ -280,27 +277,27 @@ public class TestQueryCache extends BaseTestCase {
       .eq("columnB", "someId")
       .findIds();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(colA_first).isSameAs(colA_second);
     assertThat(colA_first).hasSize(3);
     assertThat(sql).hasSize(1);
 
     // and now, ensure that we hit the database
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     colA_second = DB.find(EColAB.class)
         .setUseQueryCache(CacheMode.PUT)
         .where()
         .eq("columnB", "someId")
         .findIds();
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(1);
   }
 
   @Test
   public void findCountDifferentQueriesBit() {
-    DB.getDefault().getPluginApi().getServerCacheManager().clearAll();
+    DB.getDefault().pluginApi().cacheManager().clearAll();
     differentFindCount(q->q.bitwiseAny("id",1), q->q.bitwiseAny("id",0));
     differentFindCount(q->q.bitwiseAll("id",1), q->q.bitwiseAll("id",0));
     // differentFindCount(q->q.bitwiseNot("id",1), q->q.bitwiseNot("id",0)); NOT 1 == AND 1 = 0
@@ -314,7 +311,7 @@ public class TestQueryCache extends BaseTestCase {
   }
 
   void differentFindCount(Consumer<ExpressionList<EColAB>> q0, Consumer<ExpressionList<EColAB>> q1) {
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     ExpressionList<EColAB> el0 = DB.find(EColAB.class).setUseQueryCache(CacheMode.ON).where();
     q0.accept(el0);
@@ -324,7 +321,7 @@ public class TestQueryCache extends BaseTestCase {
     q1.accept(el1);
     el1.findCount();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(2); // different queries
   }
diff --git a/ebean-core/src/test/java/org/tests/cache/TestQueryCacheCountry.java b/ebean-test/src/test/java/org/tests/cache/TestQueryCacheCountry.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/cache/TestQueryCacheCountry.java
rename to ebean-test/src/test/java/org/tests/cache/TestQueryCacheCountry.java
index 28694eac3..bafb239eb 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestQueryCacheCountry.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestQueryCacheCountry.java
@@ -1,42 +1,38 @@
 package org.tests.cache;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheManager;
 import io.ebean.cache.ServerCacheStatistics;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryCacheCountry extends BaseTestCase {
 
-  private ServerCacheManager cacheManager = Ebean.getServerCacheManager();
-  private ServerCache queryCache = cacheManager.getQueryCache(Country.class);
-  private ServerCache beanCache = cacheManager.getBeanCache(Country.class);
+  private final ServerCacheManager cacheManager = DB.cacheManager();
+  private final ServerCache queryCache = cacheManager.queryCache(Country.class);
+  private final ServerCache beanCache = cacheManager.beanCache(Country.class);
 
   private void clearCache() {
     queryCache.clear();
     beanCache.clear();
-    queryCache.getStatistics(true);
+    queryCache.statistics(true);
   }
 
-
   @Test
   public void emptyQueryResult_expect_cached() {
 
     ResetBasicData.reset();
     clearCache();
 
-    List<Country> countryList0 = Ebean.find(Country.class)
+    List<Country> countryList0 = DB.find(Country.class)
       .setUseQueryCache(true)
       .where().startsWith("name", "XLKMG")
       .order().asc("name")
@@ -44,11 +40,11 @@ public class TestQueryCacheCountry extends BaseTestCase {
 
     assertThat(countryList0).isEmpty();
 
-    ServerCacheStatistics queryStats = queryCache.getStatistics(false);
+    ServerCacheStatistics queryStats = queryCache.statistics(false);
     assertEquals(1, queryStats.getMissCount());
     assertEquals(1, queryStats.getSize());
 
-    List<Country> countryList1 = Ebean.find(Country.class)
+    List<Country> countryList1 = DB.find(Country.class)
       .setUseQueryCache(true)
       .where().startsWith("name", "XLKMG")
       .order().asc("name")
@@ -56,7 +52,7 @@ public class TestQueryCacheCountry extends BaseTestCase {
 
     assertThat(countryList1).isEmpty();
 
-    ServerCacheStatistics queryStats1 = queryCache.getStatistics(false);
+    ServerCacheStatistics queryStats1 = queryCache.statistics(false);
     assertEquals(1, queryStats1.getMissCount());
     assertEquals(1, queryStats1.getSize());
     assertEquals(1, queryStats1.getHitCount());
@@ -69,48 +65,48 @@ public class TestQueryCacheCountry extends BaseTestCase {
     awaitL2Cache();
     clearCache();
 
-    List<Country> countryList0 = Ebean.find(Country.class)
+    List<Country> countryList0 = DB.find(Country.class)
       .setUseQueryCache(true)
       .where().raw("code = ?", "NZ")
       .findList();
 
     assertThat(countryList0.get(0).getName()).isEqualTo("New Zealand");
 
-    List<Country> countryList1 = Ebean.find(Country.class)
+    List<Country> countryList1 = DB.find(Country.class)
       .setUseQueryCache(true)
       .where().raw("code = ?", "AU")
       .findList();
 
     assertThat(countryList1.get(0).getName()).isEqualTo("Australia");
 
-    ServerCacheStatistics queryStats1 = queryCache.getStatistics(false);
+    ServerCacheStatistics queryStats1 = queryCache.statistics(false);
     assertEquals(2, queryStats1.getMissCount());
     assertEquals(2, queryStats1.getSize());
     assertEquals(0, queryStats1.getHitCount()); // no hits yet
 
 
     // we get a hit this time
-    List<Country> countryList2 = Ebean.find(Country.class)
+    List<Country> countryList2 = DB.find(Country.class)
       .setUseQueryCache(true)
       .where().raw("code = ?", "NZ")
       .findList();
 
     assertThat(countryList2.get(0).getName()).isEqualTo("New Zealand");
 
-    ServerCacheStatistics queryStats2 = queryCache.getStatistics(false);
+    ServerCacheStatistics queryStats2 = queryCache.statistics(false);
     assertEquals(2, queryStats2.getMissCount());
     assertEquals(2, queryStats2.getSize());
     assertEquals(1, queryStats2.getHitCount()); // got a hit
 
     // we get a hit on AU
-    List<Country> countryList3 = Ebean.find(Country.class)
+    List<Country> countryList3 = DB.find(Country.class)
       .setUseQueryCache(true)
       .where().raw("code = ?", "AU")
       .findList();
 
     assertThat(countryList3.get(0).getName()).isEqualTo("Australia");
 
-    ServerCacheStatistics queryStats3 = queryCache.getStatistics(false);
+    ServerCacheStatistics queryStats3 = queryCache.statistics(false);
     assertEquals(2, queryStats3.getMissCount());
     assertEquals(2, queryStats3.getSize());
     assertEquals(2, queryStats3.getHitCount()); // got another hit
@@ -124,44 +120,44 @@ public class TestQueryCacheCountry extends BaseTestCase {
     awaitL2Cache();
     clearCache();
 
-    assertEquals(0, queryCache.getStatistics(false).getSize());
+    assertEquals(0, queryCache.statistics(false).getSize());
 
-    List<Country> countryList0 = Ebean.find(Country.class)
+    List<Country> countryList0 = DB.find(Country.class)
       .setUseQueryCache(true)
       .order().asc("name")
       .findList();
 
-    assertEquals(1, queryCache.getStatistics(false).getSize());
+    assertEquals(1, queryCache.statistics(false).getSize());
     assertTrue(!countryList0.isEmpty());
 
-    List<Country> countryList1 = Ebean.find(Country.class)
+    List<Country> countryList1 = DB.find(Country.class)
       .setUseQueryCache(true)
       .order().asc("name")
       .findList();
 
-    ServerCacheStatistics statistics = queryCache.getStatistics(false);
+    ServerCacheStatistics statistics = queryCache.statistics(false);
     assertEquals(1, statistics.getSize());
     assertEquals(1, statistics.getHitCount());
-    Assert.assertSame(countryList1, countryList0);
+    assertSame(countryList1, countryList0);
 
-    Country nz = Ebean.find(Country.class, "NZ");
+    Country nz = DB.find(Country.class, "NZ");
     nz.setName("New Zealandia");
-    Ebean.save(nz);
+    DB.save(nz);
     awaitL2Cache();
 
-    statistics = queryCache.getStatistics(false);
+    statistics = queryCache.statistics(false);
     assertEquals(0, statistics.getSize());
 
-    List<Country> countryList2 = Ebean.find(Country.class)
+    List<Country> countryList2 = DB.find(Country.class)
       .setUseQueryCache(true)
       .order().asc("name")
       .findList();
 
     assertNotSame(countryList2, countryList0);
 
-    nz = Ebean.find(Country.class, "NZ");
+    nz = DB.find(Country.class, "NZ");
     nz.setName("New Zealand");
-    Ebean.save(nz);
+    DB.save(nz);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/cache/TestQueryCacheInsert.java b/ebean-test/src/test/java/org/tests/cache/TestQueryCacheInsert.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/cache/TestQueryCacheInsert.java
rename to ebean-test/src/test/java/org/tests/cache/TestQueryCacheInsert.java
index 3a5ca02ea..292a361af 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestQueryCacheInsert.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestQueryCacheInsert.java
@@ -1,26 +1,24 @@
 package org.tests.cache;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheStatistics;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 
 import java.util.List;
 import java.util.Optional;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryCacheInsert extends BaseTestCase {
 
   @Test
   public void test() {
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     EBasicVer account = new EBasicVer("junk");
     server.save(account);
@@ -42,12 +40,12 @@ public class TestQueryCacheInsert extends BaseTestCase {
     EBasicVer doda = new EBasicVer("doda");
     doda.setDescription("OddButUniqueSillyExample");
 
-    Ebean.save(doda);
+    DB.save(doda);
 
-    ServerCache queryCache = Ebean.getServerCacheManager().getQueryCache(EBasicVer.class);
-    queryCache.getStatistics(true);
+    ServerCache queryCache = DB.cacheManager().queryCache(EBasicVer.class);
+    queryCache.statistics(true);
 
-    Optional<EBasicVer> found0 = Ebean.find(EBasicVer.class)
+    Optional<EBasicVer> found0 = DB.find(EBasicVer.class)
       .where().eq("description", "OddButUniqueSillyExample")
       .setUseQueryCache(true)
       .findOneOrEmpty();
@@ -55,7 +53,7 @@ public class TestQueryCacheInsert extends BaseTestCase {
     assertTrue(found0.isPresent());
     assertHitMiss(0, 1, queryCache);
 
-    EBasicVer found1 = Ebean.find(EBasicVer.class)
+    EBasicVer found1 = DB.find(EBasicVer.class)
       .where().eq("description", "OddButUniqueSillyExample")
       .setUseQueryCache(true)
       .findOne();
@@ -65,7 +63,7 @@ public class TestQueryCacheInsert extends BaseTestCase {
   }
 
   private void assertHitMiss(int hits, int miss, ServerCache queryCache) {
-    ServerCacheStatistics stats = queryCache.getStatistics(true);
+    ServerCacheStatistics stats = queryCache.statistics(true);
     assertEquals(hits, stats.getHitCount());
     assertEquals(miss, stats.getMissCount());
   }
diff --git a/ebean-core/src/test/java/org/tests/cache/TestQueryCacheReadOnly.java b/ebean-test/src/test/java/org/tests/cache/TestQueryCacheReadOnly.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/cache/TestQueryCacheReadOnly.java
rename to ebean-test/src/test/java/org/tests/cache/TestQueryCacheReadOnly.java
index a8b1bb524..8f08e776c 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestQueryCacheReadOnly.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestQueryCacheReadOnly.java
@@ -1,29 +1,25 @@
 package org.tests.cache;
 
-import io.ebean.BaseTestCase;
-import io.ebean.CacheMode;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import io.ebean.Query;
-
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
-import org.junit.Test;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 public class TestQueryCacheReadOnly extends BaseTestCase {
 
   @Test
   public void testReadOnly() {
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
     EBasicVer account = new EBasicVer("an other junk");
     server.save(account);
-    
+
     Query<EBasicVer> baseQuery = server.find(EBasicVer.class).setUseQueryCache(CacheMode.ON);
 
     List<EBasicVer> alist = baseQuery.findList();
@@ -67,7 +63,7 @@ public class TestQueryCacheReadOnly extends BaseTestCase {
   @Test
   public void testNotReadOnly() {
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
     EBasicVer account = new EBasicVer("an other junk");
     server.save(account);
 
@@ -82,10 +78,10 @@ public class TestQueryCacheReadOnly extends BaseTestCase {
 
     Map<String,EBasicVer> amap = baseQuery.setMapKey("name").findMap();
     assertThat(amap).isNotEmpty();
-    amap.clear(); 
+    amap.clear();
     amap = baseQuery.setMapKey("name").findMap();
     assertThat(amap).isNotEmpty();
-    amap.clear(); 
+    amap.clear();
 
     Set<EBasicVer> aset = baseQuery.findSet();
     assertThat(aset).isNotEmpty();
diff --git a/ebean-core/src/test/java/org/tests/cache/TestQueryCacheTableDependency.java b/ebean-test/src/test/java/org/tests/cache/TestQueryCacheTableDependency.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/cache/TestQueryCacheTableDependency.java
rename to ebean-test/src/test/java/org/tests/cache/TestQueryCacheTableDependency.java
index 4403aa885..2fce790b7 100644
--- a/ebean-core/src/test/java/org/tests/cache/TestQueryCacheTableDependency.java
+++ b/ebean-test/src/test/java/org/tests/cache/TestQueryCacheTableDependency.java
@@ -2,11 +2,9 @@ package org.tests.cache;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.Query;
 import io.ebean.cache.ServerCache;
-
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
@@ -25,20 +23,20 @@ public class TestQueryCacheTableDependency extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    ServerCache customerCache = Ebean.getServerCacheManager().getQueryCache(Customer.class);
+    ServerCache customerCache = DB.cacheManager().queryCache(Customer.class);
     customerCache.clear();
 
-    List<Address> addrs = Ebean.find(Address.class)
+    List<Address> addrs = DB.find(Address.class)
       .where().eq("line2", "St Lukes")
       .findList();
 
-    int custs = Ebean.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
+    int custs = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
       .where().eq("billingAddress.line2", "St Lukes")
       .findCount();
 
     assertThat(custs).isEqualTo(3);
 
-    custs = Ebean.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
+    custs = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
       .where().eq("billingAddress.line2", "St Lukes")
       .findCount();
 
@@ -46,33 +44,33 @@ public class TestQueryCacheTableDependency extends BaseTestCase {
 
     Address a1 = addrs.get(0);
     a1.setLine2("St Lucky");
-    Ebean.save(a1);
+    DB.save(a1);
 
-    custs = Ebean.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
+    custs = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
       .where().eq("billingAddress.line2", "St Lukes")
       .findCount();
 
     assertThat(custs).isEqualTo(2);
 
 
-    custs = Ebean.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
+    custs = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
       .where().eq("billingAddress.line2", "St Lucky")
       .findCount();
 
     assertThat(custs).isEqualTo(1);
 
-    Ebean.update(Address.class)
+    DB.update(Address.class)
       .set("line2", "St Lucky2")
       .where().eq("line2", "St Lucky")
       .update();
 
-    custs = Ebean.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
+    custs = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
       .where().eq("billingAddress.line2", "St Lucky")
       .findCount();
 
     assertThat(custs).isEqualTo(0);
 
-    custs = Ebean.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
+    custs = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
       .where().eq("billingAddress.line2", "St Lucky2")
       .findCount();
     assertThat(custs).isEqualTo(1);
@@ -81,12 +79,12 @@ public class TestQueryCacheTableDependency extends BaseTestCase {
       .setParameters("St Lucky3", "St Lucky2")
       .execute();
 
-    custs = Ebean.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
+    custs = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
       .where().eq("billingAddress.line2", "St Lucky2")
       .findCount();
     assertThat(custs).isEqualTo(0);
 
-    custs = Ebean.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
+    custs = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
       .where().eq("billingAddress.line2", "St Lucky3")
       .findCount();
 
@@ -99,9 +97,9 @@ public class TestQueryCacheTableDependency extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Customer fi = Ebean.find(Customer.class).where().eq("name", "Fiona").findOne();
+    Customer fi = DB.find(Customer.class).where().eq("name", "Fiona").findOne();
 
-    int custCount0 = Ebean.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
+    int custCount0 = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
       .where()
       .eq("name", "Fiona")
       .isNull("contacts.phone")
@@ -109,7 +107,7 @@ public class TestQueryCacheTableDependency extends BaseTestCase {
 
     assertThat(custCount0).isEqualTo(1);
 
-    int updateRows = Ebean.update(Contact.class)
+    int updateRows = DB.update(Contact.class)
       .set("phone", "1234")
       .where()
       .eq("customer.id", fi.getId())
@@ -117,7 +115,7 @@ public class TestQueryCacheTableDependency extends BaseTestCase {
 
     assertThat(updateRows).isGreaterThan(0);
 
-    int custCount1 = Ebean.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
+    int custCount1 = DB.find(Customer.class).setUseQueryCache(true).setReadOnly(true)
       .where()
       .eq("name", "Fiona")
       .isNull("contacts.phone")
@@ -138,8 +136,8 @@ public class TestQueryCacheTableDependency extends BaseTestCase {
     child.setName("bobby");
     child.setBillingAddress(root);
     DB.save(child);
-    DB.getServerCacheManager().getQueryCache(Address.class).clear();
-    DB.getServerCacheManager().getQueryCache(Customer.class).clear();
+    DB.cacheManager().queryCache(Address.class).clear();
+    DB.cacheManager().queryCache(Customer.class).clear();
     // Test preparation finished, start the test
     Thread.sleep(10);
 
@@ -169,8 +167,8 @@ public class TestQueryCacheTableDependency extends BaseTestCase {
     child.setName("testChild");
     child.setRoot(root);
     DB.save(child);
-    DB.getServerCacheManager().getQueryCache(ECacheChild.class).clear();
-    DB.getServerCacheManager().getQueryCache(ECacheRoot.class).clear();
+    DB.cacheManager().queryCache(ECacheChild.class).clear();
+    DB.cacheManager().queryCache(ECacheRoot.class).clear();
     // Test preparation finished, start the test
     Thread.sleep(10);
     // we need this thread.sleep here, because on a fast machine, DB.save(child) and computing the
diff --git a/ebean-core/src/test/java/org/tests/cache/embeddedid/CEPCategory.java b/ebean-test/src/test/java/org/tests/cache/embeddedid/CEPCategory.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cache/embeddedid/CEPCategory.java
rename to ebean-test/src/test/java/org/tests/cache/embeddedid/CEPCategory.java
diff --git a/ebean-core/src/test/java/org/tests/cache/embeddedid/CEPProduct.java b/ebean-test/src/test/java/org/tests/cache/embeddedid/CEPProduct.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/cache/embeddedid/CEPProduct.java
rename to ebean-test/src/test/java/org/tests/cache/embeddedid/CEPProduct.java
index 064b76890..fd58c7d5c 100644
--- a/ebean-core/src/test/java/org/tests/cache/embeddedid/CEPProduct.java
+++ b/ebean-test/src/test/java/org/tests/cache/embeddedid/CEPProduct.java
@@ -2,12 +2,7 @@ package org.tests.cache.embeddedid;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Cache
diff --git a/ebean-core/src/test/java/org/tests/cache/embeddedid/CEPProductCategory.java b/ebean-test/src/test/java/org/tests/cache/embeddedid/CEPProductCategory.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cache/embeddedid/CEPProductCategory.java
rename to ebean-test/src/test/java/org/tests/cache/embeddedid/CEPProductCategory.java
diff --git a/ebean-core/src/test/java/org/tests/cache/embeddedid/CEPProductCategoryId.java b/ebean-test/src/test/java/org/tests/cache/embeddedid/CEPProductCategoryId.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cache/embeddedid/CEPProductCategoryId.java
rename to ebean-test/src/test/java/org/tests/cache/embeddedid/CEPProductCategoryId.java
diff --git a/ebean-core/src/test/java/org/tests/cache/embeddedid/TestBeanCacheEmbeddedIdPrimitives.java b/ebean-test/src/test/java/org/tests/cache/embeddedid/TestBeanCacheEmbeddedIdPrimitives.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/cache/embeddedid/TestBeanCacheEmbeddedIdPrimitives.java
rename to ebean-test/src/test/java/org/tests/cache/embeddedid/TestBeanCacheEmbeddedIdPrimitives.java
index c3d6ba97d..1c6151f1d 100644
--- a/ebean-core/src/test/java/org/tests/cache/embeddedid/TestBeanCacheEmbeddedIdPrimitives.java
+++ b/ebean-test/src/test/java/org/tests/cache/embeddedid/TestBeanCacheEmbeddedIdPrimitives.java
@@ -1,10 +1,10 @@
 package org.tests.cache.embeddedid;
 
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestBeanCacheEmbeddedIdPrimitives {
 
@@ -12,16 +12,16 @@ public class TestBeanCacheEmbeddedIdPrimitives {
   public void findById() {
 
     CEPProduct product1a = new CEPProduct("Product 01");
-    Ebean.save(product1a);
+    DB.save(product1a);
 
     assertNotNull(product1a.getId());
 
     CEPCategory category1a = new CEPCategory("Category 01");
-    Ebean.save(category1a);
+    DB.save(category1a);
 
     assertNotNull(category1a.getId());
 
-    CEPProduct product1 = Ebean.find(CEPProduct.class).setUseCache(true).where().eq("id", product1a.getId()).findOne();
+    CEPProduct product1 = DB.find(CEPProduct.class).setUseCache(true).where().eq("id", product1a.getId()).findOne();
 
     assertNotNull(product1);
 
@@ -30,7 +30,7 @@ public class TestBeanCacheEmbeddedIdPrimitives {
     });
     assertThat(product1.getProductCategories()).isEmpty();
 
-    CEPProduct product2 = Ebean.find(CEPProduct.class).setUseCache(true).where().eq("id", product1a.getId()).findOne();
+    CEPProduct product2 = DB.find(CEPProduct.class).setUseCache(true).where().eq("id", product1a.getId()).findOne();
     assertNotNull(product2);
 
     // fail here on null -> long conversion in embedded id
diff --git a/ebean-core/src/test/java/org/tests/cache/personinfo/PersonCacheEmail.java b/ebean-test/src/test/java/org/tests/cache/personinfo/PersonCacheEmail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cache/personinfo/PersonCacheEmail.java
rename to ebean-test/src/test/java/org/tests/cache/personinfo/PersonCacheEmail.java
diff --git a/ebean-core/src/test/java/org/tests/cache/personinfo/PersonCacheInfo.java b/ebean-test/src/test/java/org/tests/cache/personinfo/PersonCacheInfo.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cache/personinfo/PersonCacheInfo.java
rename to ebean-test/src/test/java/org/tests/cache/personinfo/PersonCacheInfo.java
diff --git a/ebean-core/src/test/java/org/tests/cache/personinfo/PersonCacheTests.java b/ebean-test/src/test/java/org/tests/cache/personinfo/PersonCacheTests.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/cache/personinfo/PersonCacheTests.java
rename to ebean-test/src/test/java/org/tests/cache/personinfo/PersonCacheTests.java
index 20935a319..bf23b590f 100644
--- a/ebean-core/src/test/java/org/tests/cache/personinfo/PersonCacheTests.java
+++ b/ebean-test/src/test/java/org/tests/cache/personinfo/PersonCacheTests.java
@@ -4,8 +4,8 @@ import io.ebean.DB;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheRegion;
 import io.ebean.cache.ServerCacheStatistics;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -13,7 +13,7 @@ import java.util.Arrays;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class PersonCacheTests {
 
@@ -21,10 +21,10 @@ public class PersonCacheTests {
 
   private final List<Object> ids = Arrays.asList("E001", "E002", "E003");
 
-  private ServerCache beanCacheInfo = DB.getDefault().getServerCacheManager().getBeanCache(PersonCacheInfo.class);
-  private ServerCache beanCacheEmail = DB.getDefault().getServerCacheManager().getBeanCache(PersonCacheEmail.class);
+  private ServerCache beanCacheInfo = DB.getDefault().cacheManager().beanCache(PersonCacheInfo.class);
+  private ServerCache beanCacheEmail = DB.getDefault().cacheManager().beanCache(PersonCacheEmail.class);
 
-  private ServerCacheRegion region = DB.getDefault().getServerCacheManager().getRegion("email");
+  private ServerCacheRegion region = DB.getDefault().cacheManager().region("email");
 
   private void insert(int id, String email) {
 
@@ -49,14 +49,14 @@ public class PersonCacheTests {
 
     addTestData();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.find(PersonCacheInfo.class)
       .select("personId") // do not fetch name
       .setUseCache(true)
       .findList();
 
-    beanCacheInfo.getStatistics(true);
+    beanCacheInfo.statistics(true);
 
     List<PersonCacheEmail> emailList =
       DB.find(PersonCacheEmail.class)
@@ -70,10 +70,10 @@ public class PersonCacheTests {
       assertThat(email.getPersonInfo().getName()).isNotNull();
     }
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(3);
 
-    assertThat(beanCacheInfo.getStatistics(true).getHitCount()).isEqualTo(3);
+    assertThat(beanCacheInfo.statistics(true).getHitCount()).isEqualTo(3);
 
     // force cache misses on PersonCacheEmail
     beanCacheEmail.clear();
@@ -91,10 +91,10 @@ public class PersonCacheTests {
       assertThat(email.getPersonInfo().getName()).isNotNull();
     }
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
 
-    assertThat(beanCacheInfo.getStatistics(true).getHitCount()).isEqualTo(3);
+    assertThat(beanCacheInfo.statistics(true).getHitCount()).isEqualTo(3);
 
     turnOffRegion_expect_noCacheUse();
 
@@ -103,7 +103,7 @@ public class PersonCacheTests {
   private void turnOffRegion_expect_noCacheUse() {
 
     assertTrue(region.isEnabled());
-    beanCacheEmail.getStatistics(true);
+    beanCacheEmail.statistics(true);
 
     log.info("Disabled region ...");
     region.setEnabled(false);
@@ -116,7 +116,7 @@ public class PersonCacheTests {
     }
 
     // assert that we didn't hit the cache
-    ServerCacheStatistics statistics = beanCacheEmail.getStatistics(true);
+    ServerCacheStatistics statistics = beanCacheEmail.statistics(true);
     assertThat(statistics.getHitCount()).isEqualTo(0);
     assertThat(statistics.getMissCount()).isEqualTo(0);
 
@@ -131,7 +131,7 @@ public class PersonCacheTests {
     }
 
     // assert that we DID hit the cache
-    statistics = beanCacheEmail.getStatistics(true);
+    statistics = beanCacheEmail.statistics(true);
     assertThat(statistics.getHitCount()).isEqualTo(3);
     assertThat(statistics.getMissCount()).isEqualTo(0);
   }
diff --git a/ebean-core/src/test/java/org/tests/cache/personinfo/PersonOther.java b/ebean-test/src/test/java/org/tests/cache/personinfo/PersonOther.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cache/personinfo/PersonOther.java
rename to ebean-test/src/test/java/org/tests/cache/personinfo/PersonOther.java
diff --git a/ebean-core/src/test/java/org/tests/cache/personinfo/TestStringIdOnly.java b/ebean-test/src/test/java/org/tests/cache/personinfo/TestStringIdOnly.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/cache/personinfo/TestStringIdOnly.java
rename to ebean-test/src/test/java/org/tests/cache/personinfo/TestStringIdOnly.java
index 6379491ff..3434c48eb 100644
--- a/ebean-core/src/test/java/org/tests/cache/personinfo/TestStringIdOnly.java
+++ b/ebean-test/src/test/java/org/tests/cache/personinfo/TestStringIdOnly.java
@@ -2,7 +2,7 @@ package org.tests.cache.personinfo;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/callable/TestMysqlCallable.java b/ebean-test/src/test/java/org/tests/callable/TestMysqlCallable.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/callable/TestMysqlCallable.java
rename to ebean-test/src/test/java/org/tests/callable/TestMysqlCallable.java
index 11db943a6..6ead0106b 100644
--- a/ebean-core/src/test/java/org/tests/callable/TestMysqlCallable.java
+++ b/ebean-test/src/test/java/org/tests/callable/TestMysqlCallable.java
@@ -2,13 +2,13 @@ package org.tests.callable;
 
 import io.ebean.BaseTestCase;
 import io.ebean.CallableSql;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
-import org.junit.Ignore;
-import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestMysqlCallable extends BaseTestCase {
 
@@ -28,12 +28,12 @@ public class TestMysqlCallable extends BaseTestCase {
   /**
    * Only run this test manually against MySQL with the above stored procedure.
    */
-  @Ignore
+  @Disabled
   @Test
   public void test() {
 
     // mysql specific test
-    EbeanServer server = Ebean.getServer("mysql");
+    Database server = DB.byName("mysql");
 
     EBasic basic = new EBasic();
     basic.setName("calling");
diff --git a/ebean-core/src/test/java/org/tests/cascade/COOne.java b/ebean-test/src/test/java/org/tests/cascade/COOne.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cascade/COOne.java
rename to ebean-test/src/test/java/org/tests/cascade/COOne.java
diff --git a/ebean-core/src/test/java/org/tests/cascade/COOneMany.java b/ebean-test/src/test/java/org/tests/cascade/COOneMany.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cascade/COOneMany.java
rename to ebean-test/src/test/java/org/tests/cascade/COOneMany.java
diff --git a/ebean-core/src/test/java/org/tests/cascade/CORoot.java b/ebean-test/src/test/java/org/tests/cascade/CORoot.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cascade/CORoot.java
rename to ebean-test/src/test/java/org/tests/cascade/CORoot.java
diff --git a/ebean-core/src/test/java/org/tests/cascade/OmCacheOrderedDetail.java b/ebean-test/src/test/java/org/tests/cascade/OmCacheOrderedDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cascade/OmCacheOrderedDetail.java
rename to ebean-test/src/test/java/org/tests/cascade/OmCacheOrderedDetail.java
diff --git a/ebean-core/src/test/java/org/tests/cascade/OmCacheOrderedMaster.java b/ebean-test/src/test/java/org/tests/cascade/OmCacheOrderedMaster.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/cascade/OmCacheOrderedMaster.java
rename to ebean-test/src/test/java/org/tests/cascade/OmCacheOrderedMaster.java
index 7e0dd4df3..093a2946f 100644
--- a/ebean-core/src/test/java/org/tests/cascade/OmCacheOrderedMaster.java
+++ b/ebean-test/src/test/java/org/tests/cascade/OmCacheOrderedMaster.java
@@ -2,11 +2,7 @@ package org.tests.cascade;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/cascade/OmOrderedDetail.java b/ebean-test/src/test/java/org/tests/cascade/OmOrderedDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/cascade/OmOrderedDetail.java
rename to ebean-test/src/test/java/org/tests/cascade/OmOrderedDetail.java
diff --git a/ebean-core/src/test/java/org/tests/cascade/OmOrderedMaster.java b/ebean-test/src/test/java/org/tests/cascade/OmOrderedMaster.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/cascade/OmOrderedMaster.java
rename to ebean-test/src/test/java/org/tests/cascade/OmOrderedMaster.java
index 8607084d3..89141a345 100644
--- a/ebean-core/src/test/java/org/tests/cascade/OmOrderedMaster.java
+++ b/ebean-test/src/test/java/org/tests/cascade/OmOrderedMaster.java
@@ -1,10 +1,6 @@
 package org.tests.cascade;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/cascade/RelDetail.java b/ebean-test/src/test/java/org/tests/cascade/RelDetail.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/cascade/RelDetail.java
rename to ebean-test/src/test/java/org/tests/cascade/RelDetail.java
index 170f194b0..29e494539 100644
--- a/ebean-core/src/test/java/org/tests/cascade/RelDetail.java
+++ b/ebean-test/src/test/java/org/tests/cascade/RelDetail.java
@@ -1,13 +1,8 @@
 package org.tests.cascade;
 
+import javax.persistence.*;
 import java.util.List;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
-
 @Entity
 public class RelDetail {
 
diff --git a/ebean-core/src/test/java/org/tests/cascade/RelMaster.java b/ebean-test/src/test/java/org/tests/cascade/RelMaster.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/cascade/RelMaster.java
rename to ebean-test/src/test/java/org/tests/cascade/RelMaster.java
index e7a736b0f..06bf64f18 100644
--- a/ebean-core/src/test/java/org/tests/cascade/RelMaster.java
+++ b/ebean-test/src/test/java/org/tests/cascade/RelMaster.java
@@ -1,10 +1,6 @@
 package org.tests.cascade;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class RelMaster {
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestCascadeOrphanStatelessUpdate.java b/ebean-test/src/test/java/org/tests/cascade/TestCascadeOrphanStatelessUpdate.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/cascade/TestCascadeOrphanStatelessUpdate.java
rename to ebean-test/src/test/java/org/tests/cascade/TestCascadeOrphanStatelessUpdate.java
index 178c5271c..5468657b0 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestCascadeOrphanStatelessUpdate.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestCascadeOrphanStatelessUpdate.java
@@ -3,14 +3,14 @@ package org.tests.cascade;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
 import static java.util.Arrays.asList;
 import static java.util.stream.Collectors.toList;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestCascadeOrphanStatelessUpdate extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestDeleteO2MOrphans.java b/ebean-test/src/test/java/org/tests/cascade/TestDeleteO2MOrphans.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/cascade/TestDeleteO2MOrphans.java
rename to ebean-test/src/test/java/org/tests/cascade/TestDeleteO2MOrphans.java
index f4356d2bf..324774d01 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestDeleteO2MOrphans.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestDeleteO2MOrphans.java
@@ -2,7 +2,7 @@ package org.tests.cascade;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestJsonMarshallingOTM.java b/ebean-test/src/test/java/org/tests/cascade/TestJsonMarshallingOTM.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/cascade/TestJsonMarshallingOTM.java
rename to ebean-test/src/test/java/org/tests/cascade/TestJsonMarshallingOTM.java
index 63e47b301..bd45cc8ba 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestJsonMarshallingOTM.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestJsonMarshallingOTM.java
@@ -1,7 +1,7 @@
 package org.tests.cascade;
 
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestMasterDetailDelete.java b/ebean-test/src/test/java/org/tests/cascade/TestMasterDetailDelete.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/cascade/TestMasterDetailDelete.java
rename to ebean-test/src/test/java/org/tests/cascade/TestMasterDetailDelete.java
index 7ff1477cc..c1eca9d9b 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestMasterDetailDelete.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestMasterDetailDelete.java
@@ -2,12 +2,11 @@ package org.tests.cascade;
 
 import io.ebean.BaseTestCase;
 import io.ebean.Transaction;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
-import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestMasterDetailDelete extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestMultiCascadeBatch.java b/ebean-test/src/test/java/org/tests/cascade/TestMultiCascadeBatch.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/cascade/TestMultiCascadeBatch.java
rename to ebean-test/src/test/java/org/tests/cascade/TestMultiCascadeBatch.java
index f0e007547..94cc8b6f7 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestMultiCascadeBatch.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestMultiCascadeBatch.java
@@ -2,12 +2,11 @@ package org.tests.cascade;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.Transaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.tests.model.site.DataContainer;
 import org.tests.model.site.Site;
 import org.tests.model.site.SiteAddress;
@@ -21,12 +20,12 @@ public class TestMultiCascadeBatch extends BaseTestCase {
 
   private Transaction txn;
 
-  @Before
+  @BeforeEach
   public void before() {
-    txn = Ebean.beginTransaction();
+    txn = DB.beginTransaction();
   }
 
-  @After
+  @AfterEach
   public void after() {
     if (txn != null) {
       txn.end();
@@ -45,10 +44,10 @@ public class TestMultiCascadeBatch extends BaseTestCase {
     grandparent.setChildren(Collections.singletonList(parent));
     parent.setChildren(Collections.singletonList(child));
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     grandparent.save();
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
 
     final List<Site> list = DB.find(Site.class).where()
       .idIn(grandparent.getId(), parent.getId(), child.getId())
@@ -69,7 +68,7 @@ public class TestMultiCascadeBatch extends BaseTestCase {
 
     final Site mainSite = new Site();
     mainSite.setName("mainSite");
-    Ebean.save(mainSite);
+    DB.save(mainSite);
 
     // create child including data
     final Site childSite = new Site();
@@ -88,7 +87,7 @@ public class TestMultiCascadeBatch extends BaseTestCase {
     mainSite.getChildren().add(childSite);
     mainSite.setName("a different name");
 
-    Ebean.save(mainSite);
+    DB.save(mainSite);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestOnlyKillOrphans.java b/ebean-test/src/test/java/org/tests/cascade/TestOnlyKillOrphans.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/cascade/TestOnlyKillOrphans.java
rename to ebean-test/src/test/java/org/tests/cascade/TestOnlyKillOrphans.java
index 8da56d1b1..1fecd07d9 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestOnlyKillOrphans.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestOnlyKillOrphans.java
@@ -2,7 +2,7 @@ package org.tests.cascade;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestOrderedList.java b/ebean-test/src/test/java/org/tests/cascade/TestOrderedList.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/cascade/TestOrderedList.java
rename to ebean-test/src/test/java/org/tests/cascade/TestOrderedList.java
index a306cb105..f567928e3 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestOrderedList.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestOrderedList.java
@@ -2,8 +2,8 @@ package org.tests.cascade;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
 import java.util.List;
@@ -22,10 +22,10 @@ public class TestOrderedList extends BaseTestCase {
       details.add(new OmOrderedDetail("d"+i));
     }
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.save(master);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql.size()).isGreaterThan(1);
     assertSql(sql.get(0)).contains("insert into om_ordered_master");
     boolean hasId = sql.get(1).contains(" (id, name");
@@ -38,14 +38,14 @@ public class TestOrderedList extends BaseTestCase {
     // update without any changes
     DB.save(master);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty();
 
 
     // update just changing master
     master.setName("m1-mod");
     DB.save(master);
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("update om_ordered_master set name=?, version=?");
 
@@ -57,12 +57,12 @@ public class TestOrderedList extends BaseTestCase {
     OmOrderedMaster fresh = DB.find(OmOrderedMaster.class).setId(id).fetch("details").findOne();
     List<OmOrderedDetail> details1 = fresh.getDetails();
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertSql(sql.get(0)).contains("order by t0.id, t1.sort_order");
 
     // fetched, not dirty
     DB.save(fresh);
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty();
 
 
@@ -76,7 +76,7 @@ public class TestOrderedList extends BaseTestCase {
 
     DB.save(fresh);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(7);
     assertSql(sql.get(0)).contains("update om_ordered_master set name=?, version=?");
     assertSql(sql.get(1)).contains("update om_ordered_detail set version=?, sort_order=? where id=? and version=?");
@@ -85,7 +85,7 @@ public class TestOrderedList extends BaseTestCase {
     fresh.setName("m1-mod3");
     DB.save(fresh);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("update om_ordered_master set name=?, version=? where id=? and version=?; -- bind(m1-mod3");
     assertSql(sql.get(1)).contains("update om_ordered_detail set name=?, version=?, sort_order=? where id=? and version=?");
@@ -93,7 +93,7 @@ public class TestOrderedList extends BaseTestCase {
 
     DB.delete(fresh);
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("delete from om_ordered_detail where master_id = ?");
     assertSqlBind(sql.get(1));
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestPrivateOwned.java b/ebean-test/src/test/java/org/tests/cascade/TestPrivateOwned.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/cascade/TestPrivateOwned.java
rename to ebean-test/src/test/java/org/tests/cascade/TestPrivateOwned.java
index 5c9ee8235..66f14e982 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestPrivateOwned.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestPrivateOwned.java
@@ -1,19 +1,19 @@
 package org.tests.cascade;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.BeanCollection;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TSDetail;
 import org.tests.model.basic.TSMaster;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
 
 import java.util.List;
 import java.util.Set;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestPrivateOwned extends BaseTestCase {
 
@@ -26,9 +26,9 @@ public class TestPrivateOwned extends BaseTestCase {
     m0.addDetail(new TSDetail("m1 detail 1"));
     m0.addDetail(new TSDetail("m1 detail 2"));
 
-    Ebean.save(m0);
+    DB.save(m0);
 
-    TSMaster master = Ebean.find(TSMaster.class, m0.getId());
+    TSMaster master = DB.find(TSMaster.class, m0.getId());
     List<TSDetail> details = master.getDetails();
 
     TSDetail removedDetail = details.remove(1);
@@ -40,15 +40,15 @@ public class TestPrivateOwned extends BaseTestCase {
     assertTrue(modifyRemovals.size() == 1);
     assertTrue(modifyRemovals.contains(removedDetail));
 
-    Ebean.save(master);
+    DB.save(master);
 
-    TSMaster masterReload = Ebean.find(TSMaster.class, m0.getId());
+    TSMaster masterReload = DB.find(TSMaster.class, m0.getId());
     List<TSDetail> detailsReload = masterReload.getDetails();
 
     // the removed bean has really been removed
     assertTrue(detailsReload.size() == 1);
 
-    TSMaster master3 = Ebean.find(TSMaster.class, m0.getId());
+    TSMaster master3 = DB.find(TSMaster.class, m0.getId());
     List<TSDetail> details3 = master3.getDetails();
     details3.clear();
   }
@@ -63,24 +63,24 @@ public class TestPrivateOwned extends BaseTestCase {
     m0.addDetail(new TSDetail("m2 detail 1"));
     m0.addDetail(new TSDetail("m2 detail 2"));
 
-    Ebean.save(m0);
+    DB.save(m0);
     assertThat(m0.getDetails()).hasSize(2);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     m0.getDetails().remove(0);
-    Ebean.save(m0);
+    DB.save(m0);
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(2);
     assertThat(loggedSql.get(0)).contains("delete from t_detail_with_other_namexxxyy where id=?");
     assertSqlBind(loggedSql.get(1));
 
-    TSMaster masterReload = Ebean.find(TSMaster.class, m0.getId());
+    TSMaster masterReload = DB.find(TSMaster.class, m0.getId());
     assertThat(masterReload.getDetails()).hasSize(1);
 
-    LoggedSqlCollector.start();
-    Ebean.save(m0);
-    loggedSql = LoggedSqlCollector.stop();
+    LoggedSql.start();
+    DB.save(m0);
+    loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(0);
 
   }
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestPrivateOwnedAddRemoveOrphan.java b/ebean-test/src/test/java/org/tests/cascade/TestPrivateOwnedAddRemoveOrphan.java
similarity index 59%
rename from ebean-core/src/test/java/org/tests/cascade/TestPrivateOwnedAddRemoveOrphan.java
rename to ebean-test/src/test/java/org/tests/cascade/TestPrivateOwnedAddRemoveOrphan.java
index 42321dc43..376389835 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestPrivateOwnedAddRemoveOrphan.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestPrivateOwnedAddRemoveOrphan.java
@@ -1,11 +1,12 @@
 package org.tests.cascade;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TSDetail;
 import org.tests.model.basic.TSMaster;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestPrivateOwnedAddRemoveOrphan extends BaseTestCase {
 
@@ -14,20 +15,20 @@ public class TestPrivateOwnedAddRemoveOrphan extends BaseTestCase {
 
     // setup
     TSMaster master0 = new TSMaster();
-    Ebean.save(master0);
+    DB.save(master0);
 
     // act
-    TSMaster master1 = Ebean.find(master0.getClass(), master0.getId());
+    TSMaster master1 = DB.find(master0.getClass(), master0.getId());
 
     TSDetail tsDetail = new TSDetail();
     // Add then remove a bean that was never saved (to the DB)
     master1.getDetails().add(tsDetail);
     master1.getDetails().remove(tsDetail);
 
-    Ebean.save(master1);
+    DB.save(master1);
 
-    TSMaster master2 = Ebean.find(master1.getClass(), master1.getId());
+    TSMaster master2 = DB.find(master1.getClass(), master1.getId());
 
-    Assert.assertTrue(master2.getDetails().isEmpty());
+    assertTrue(master2.getDetails().isEmpty());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestPrivateOwnedCascadeOrder.java b/ebean-test/src/test/java/org/tests/cascade/TestPrivateOwnedCascadeOrder.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/cascade/TestPrivateOwnedCascadeOrder.java
rename to ebean-test/src/test/java/org/tests/cascade/TestPrivateOwnedCascadeOrder.java
index d3b81fa05..ebc6fe9bc 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestPrivateOwnedCascadeOrder.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestPrivateOwnedCascadeOrder.java
@@ -1,9 +1,9 @@
 package org.tests.cascade;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TSDetail;
 import org.tests.model.basic.TSMaster;
 
@@ -17,16 +17,16 @@ public class TestPrivateOwnedCascadeOrder extends BaseTestCase {
     master.getDetails().add(new TSDetail("c97", "ONE"));
     master.getDetails().add(new TSDetail("c96", "TWO"));
 
-    Ebean.save(master);
+    DB.save(master);
 
     // act
-    TSMaster master1 = Ebean.find(master.getClass(), master.getId());
+    TSMaster master1 = DB.find(master.getClass(), master.getId());
 
     // Check Ebean deletes the existing c97 first as the unique values clash
     master1.getDetails().clear();
     master1.getDetails().add(new TSDetail("c98", "TWO"));
 
-    Ebean.save(master1);
+    DB.save(master1);
   }
 
   @Test
@@ -37,25 +37,25 @@ public class TestPrivateOwnedCascadeOrder extends BaseTestCase {
     master.getDetails().add(new TSDetail("d97", "ONE2"));
     master.getDetails().add(new TSDetail("d96", "TWO2"));
 
-    Ebean.save(master);
+    DB.save(master);
 
     // act
-    TSMaster master1 = Ebean.find(master.getClass(), master.getId());
+    TSMaster master1 = DB.find(master.getClass(), master.getId());
 
     // Check Ebean deletes the existing d96 first as the unique values clash
-    Transaction transaction = Ebean.beginTransaction();
+    Transaction transaction = DB.beginTransaction();
     try {
       master1.getDetails().clear();
       master1.getDetails().add(new TSDetail("d98", "TWO2"));
 
-      Ebean.save(master1);
+      DB.save(master1);
       transaction.commit();
     } finally {
       transaction.end();
     }
 
     // Cleanup
-    Ebean.find(TSDetail.class).where().or().eq("name", "d97").eq("name", "d98").delete();
-    Ebean.delete(master1);
+    DB.find(TSDetail.class).where().or().eq("name", "d97").eq("name", "d98").delete();
+    DB.delete(master1);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/cascade/TestPrivateOwnedIgnoreTransientOrphan.java b/ebean-test/src/test/java/org/tests/cascade/TestPrivateOwnedIgnoreTransientOrphan.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/cascade/TestPrivateOwnedIgnoreTransientOrphan.java
rename to ebean-test/src/test/java/org/tests/cascade/TestPrivateOwnedIgnoreTransientOrphan.java
index 462956d94..f265bf341 100644
--- a/ebean-core/src/test/java/org/tests/cascade/TestPrivateOwnedIgnoreTransientOrphan.java
+++ b/ebean-test/src/test/java/org/tests/cascade/TestPrivateOwnedIgnoreTransientOrphan.java
@@ -1,14 +1,16 @@
 package org.tests.cascade;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TSDetail;
 import org.tests.model.basic.TSMaster;
-import org.junit.Assert;
-import org.junit.Test;
 
 import javax.persistence.OptimisticLockException;
 
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestPrivateOwnedIgnoreTransientOrphan extends BaseTestCase {
 
   @Test
@@ -23,24 +25,24 @@ public class TestPrivateOwnedIgnoreTransientOrphan extends BaseTestCase {
     /** recovered after transient child ignored **/
     TSMaster master2 = null;
 
-    Ebean.save(master0);
+    DB.save(master0);
 
-    master1 = Ebean.find(master0.getClass(), master0.getId());
+    master1 = DB.find(master0.getClass(), master0.getId());
 
     // Add then remove a bean that was never saved (to the DB)
     master1.getDetails().add(new TSDetail());
     master1.getDetails().clear();
 
     try {
-      Ebean.save(master1);
+      DB.save(master1);
     } catch (OptimisticLockException exception) {
       // Occured when the "unsaved" bean was wrongly being deleted
-      Assert.fail("Optimistic lock exception wrongly thrown: " + exception.getMessage());
+      fail("Optimistic lock exception wrongly thrown: " + exception.getMessage());
       return;
     }
 
-    master2 = master1 = Ebean.find(master1.getClass(), master1.getId());
+    master2 = master1 = DB.find(master1.getClass(), master1.getId());
 
-    Assert.assertTrue(master2.getDetails().isEmpty());
+    assertTrue(master2.getDetails().isEmpty());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/changelog/TestChangeLog.java b/ebean-test/src/test/java/org/tests/changelog/TestChangeLog.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/changelog/TestChangeLog.java
rename to ebean-test/src/test/java/org/tests/changelog/TestChangeLog.java
index 75f8c97bd..02b03ad73 100644
--- a/ebean-core/src/test/java/org/tests/changelog/TestChangeLog.java
+++ b/ebean-test/src/test/java/org/tests/changelog/TestChangeLog.java
@@ -8,19 +8,11 @@ import io.ebean.DatabaseFactory;
 import io.ebean.annotation.ChangeLog;
 import io.ebean.config.DatabaseConfig;
 import io.ebean.event.BeanPersistRequest;
-import io.ebean.event.changelog.BeanChange;
-import io.ebean.event.changelog.ChangeLogFilter;
-import io.ebean.event.changelog.ChangeLogListener;
-import io.ebean.event.changelog.ChangeLogPrepare;
-import io.ebean.event.changelog.ChangeLogRegister;
-import io.ebean.event.changelog.ChangeSet;
-import io.ebean.event.changelog.ChangeType;
-import io.ebean.event.changelog.TxnState;
-import io.ebeantest.LoggedSql;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import io.ebean.event.changelog.*;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicChangeLog;
 import org.tests.model.json.PlainBean;
 
@@ -28,7 +20,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestChangeLog extends BaseTestCase {
 
@@ -40,12 +32,12 @@ public class TestChangeLog extends BaseTestCase {
 
   Database server;
 
-  @Before
+  @BeforeEach
   public void setup() {
     server = createServer();
   }
 
-  @After
+  @AfterEach
   public void shutdown() {
     server.shutdown();
   }
@@ -133,7 +125,7 @@ public class TestChangeLog extends BaseTestCase {
     assertThat(change.getEvent()).isEqualTo(ChangeType.DELETE);
     assertThat(change.getData()).isNull();
   }
-  
+
   @Test
   public void testWithJsonMutationDetection() {
 
@@ -142,23 +134,23 @@ public class TestChangeLog extends BaseTestCase {
     bean.setShortDescription("hello");
     PlainBean jsonBean = new PlainBean();
     bean.setPlainBean(jsonBean);
-    jsonBean.setName("A");    
+    jsonBean.setName("A");
     server.save(bean);
-    
+
     BeanChange change = firstChange();
     assertThat(change.getEvent()).isEqualTo(ChangeType.INSERT);
-    
+
     jsonBean.setName("B");
     LoggedSql.start();
     server.save(bean);
     assertThat(LoggedSql.stop()).isNotEmpty();
-    
+
     change = firstChange();
     assertThat(change.getEvent()).isEqualTo(ChangeType.UPDATE);
     assertThat(change.getData()).contains("\"plainBean\":{\"name\":\"B\"");
     assertThat(change.getOldData()).contains("\"plainBean\":{\"name\":\"A\"");
   }
-  
+
   @Test
   public void testMutationWithCache() throws Exception {
     EBasicChangeLog bean = new EBasicChangeLog();
diff --git a/ebean-core/src/test/java/org/tests/changelog/TestChangeLogInt.java b/ebean-test/src/test/java/org/tests/changelog/TestChangeLogInt.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/changelog/TestChangeLogInt.java
rename to ebean-test/src/test/java/org/tests/changelog/TestChangeLogInt.java
index 3cd3dfa39..48d855918 100644
--- a/ebean-core/src/test/java/org/tests/changelog/TestChangeLogInt.java
+++ b/ebean-test/src/test/java/org/tests/changelog/TestChangeLogInt.java
@@ -1,8 +1,8 @@
 package org.tests.changelog;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicChangeLog;
 
 public class TestChangeLogInt extends BaseTestCase {
@@ -13,10 +13,10 @@ public class TestChangeLogInt extends BaseTestCase {
     EBasicChangeLog bean3 = new EBasicChangeLog();
     bean3.setName("bean3");
     bean3.setShortDescription("bean3 hi");
-    Ebean.save(bean3);
+    DB.save(bean3);
 
     bean3.setName("mod bean3");
     bean3.setShortDescription("update bean3");
-    Ebean.save(bean3);
+    DB.save(bean3);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/TestCKeyDelete.java b/ebean-test/src/test/java/org/tests/compositekeys/TestCKeyDelete.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/compositekeys/TestCKeyDelete.java
rename to ebean-test/src/test/java/org/tests/compositekeys/TestCKeyDelete.java
index acd40ad4c..eeb66a5e4 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/TestCKeyDelete.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/TestCKeyDelete.java
@@ -2,15 +2,15 @@ package org.tests.compositekeys;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.CKeyParent;
 import org.tests.model.basic.CKeyParentId;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestCKeyDelete extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/TestCKeyIdInExpression.java b/ebean-test/src/test/java/org/tests/compositekeys/TestCKeyIdInExpression.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/compositekeys/TestCKeyIdInExpression.java
rename to ebean-test/src/test/java/org/tests/compositekeys/TestCKeyIdInExpression.java
index b8a0f0781..4545424d2 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/TestCKeyIdInExpression.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/TestCKeyIdInExpression.java
@@ -1,19 +1,20 @@
 package org.tests.compositekeys;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.composite.RCustomer;
 import org.tests.model.composite.RCustomerKey;
 import org.tests.model.composite.ROrder;
 import org.tests.model.composite.ROrderPK;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestCKeyIdInExpression extends BaseTestCase {
 
   @Test
@@ -29,7 +30,7 @@ public class TestCKeyIdInExpression extends BaseTestCase {
     rCustomer.setKey(customerKey);
     rCustomer.setDescription("some foo for ms sql server");
 
-    Ebean.save(rCustomer);
+    DB.save(rCustomer);
 
     ROrderPK k0 = new ROrderPK("compa", 100);
     ROrder rOrder = new ROrder();
@@ -37,14 +38,14 @@ public class TestCKeyIdInExpression extends BaseTestCase {
     rOrder.setOrderPK(k0);
     rOrder.setItem("Chair");
 
-    Ebean.save(rOrder);
+    DB.save(rOrder);
   }
 
   //@Test
   public void notRanAutomatically() {
 
     //EbeanServer server = CreateIdExpandedFormServer.create();
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     ROrderPK k0 = new ROrderPK("compa", 100);
     ROrderPK k1 = new ROrderPK("compa", 101);
@@ -62,14 +63,14 @@ public class TestCKeyIdInExpression extends BaseTestCase {
     query.findList();
     String sql = query.getGeneratedSql();
 
-    Assert.assertTrue(sql.contains("(t0.company=? and t0.order_number=?) or"));
+    assertTrue(sql.contains("(t0.company=? and t0.order_number=?) or"));
 
     Query<ROrder> query2 = server.find(ROrder.class).setId(k0);
 
     query2.findOne();
     sql = query2.getGeneratedSql();
-    Assert.assertTrue(sql.contains("t0.company = ? "));
-    Assert.assertTrue(sql.contains(" and t0.order_number = ?"));
+    assertTrue(sql.contains("t0.company = ? "));
+    assertTrue(sql.contains(" and t0.order_number = ?"));
 
     server.delete(ROrder.class, k0);
 
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/TestCKeyLazyLoad.java b/ebean-test/src/test/java/org/tests/compositekeys/TestCKeyLazyLoad.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/compositekeys/TestCKeyLazyLoad.java
rename to ebean-test/src/test/java/org/tests/compositekeys/TestCKeyLazyLoad.java
index 7e5aed4d0..26db614db 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/TestCKeyLazyLoad.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/TestCKeyLazyLoad.java
@@ -1,30 +1,30 @@
 package org.tests.compositekeys;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.PagedList;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.CKeyAssoc;
 import org.tests.model.basic.CKeyDetail;
 import org.tests.model.basic.CKeyParent;
 import org.tests.model.basic.CKeyParentId;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestCKeyLazyLoad extends BaseTestCase {
 
   @Test
   public void test() {
 
-    Ebean.find(CKeyDetail.class).delete();
-    Ebean.find(CKeyParent.class).delete();
-    Ebean.find(CKeyAssoc.class).delete();
+    DB.find(CKeyDetail.class).delete();
+    DB.find(CKeyParent.class).delete();
+    DB.find(CKeyAssoc.class).delete();
 
     CKeyParentId id = new CKeyParentId(1, "one");
 
@@ -38,7 +38,7 @@ public class TestCKeyLazyLoad extends BaseTestCase {
     p.add(new CKeyDetail("somethine one"));
     p.add(new CKeyDetail("somethine two"));
 
-    Ebean.save(p);
+    DB.save(p);
 
     CKeyAssoc assoc2 = new CKeyAssoc();
     assoc2.setAssocOne("assocTwo");
@@ -52,18 +52,18 @@ public class TestCKeyLazyLoad extends BaseTestCase {
     p2.add(new CKeyDetail("somethine one"));
     p2.add(new CKeyDetail("somethine two"));
 
-    Ebean.save(p2);
+    DB.save(p2);
 
     exerciseMaxRowsQuery_with_embeddedId();
 
     CKeyParentId searchId = new CKeyParentId(1, "one");
 
-    CKeyParent found = Ebean.find(CKeyParent.class).where().idEq(searchId).findOne();
+    CKeyParent found = DB.find(CKeyParent.class).where().idEq(searchId).findOne();
 
     assertNotNull(found);
     assertEquals(2, found.getDetails().size());
 
-    List<CKeyParent> list = Ebean.find(CKeyParent.class).findList();
+    List<CKeyParent> list = DB.find(CKeyParent.class).findList();
 
     assertThat(list.size()).isGreaterThan(1);
 
@@ -77,13 +77,13 @@ public class TestCKeyLazyLoad extends BaseTestCase {
     idList.add(id);
     idList.add(id2);
 
-    Query<CKeyParent> queryIdIn = Ebean.find(CKeyParent.class).where().idIn(idList).query();
+    Query<CKeyParent> queryIdIn = DB.find(CKeyParent.class).where().idIn(idList).query();
 
     List<CKeyParent> idInTestList = queryIdIn.findList();
 
     assertThat(idInTestList.size()).isEqualTo(2);
 
-    List<CKeyParent> idInTestList2 = Ebean.find(CKeyParent.class).where().idIn(id, id2).findList();
+    List<CKeyParent> idInTestList2 = DB.find(CKeyParent.class).where().idIn(id, id2).findList();
     assertThat(idInTestList2).hasSameSizeAs(idInTestList);
   }
 
@@ -92,7 +92,7 @@ public class TestCKeyLazyLoad extends BaseTestCase {
    */
   private void exerciseMaxRowsQuery_with_embeddedId() {
 
-    PagedList<CKeyParent> siteUserPage = Ebean.find(CKeyParent.class).where()
+    PagedList<CKeyParent> siteUserPage = DB.find(CKeyParent.class).where()
       .order("name asc")
       .setMaxRows(10)
       .findPagedList();
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/TestCaoCompositeKeyWithAnnotationOverrides.java b/ebean-test/src/test/java/org/tests/compositekeys/TestCaoCompositeKeyWithAnnotationOverrides.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/compositekeys/TestCaoCompositeKeyWithAnnotationOverrides.java
rename to ebean-test/src/test/java/org/tests/compositekeys/TestCaoCompositeKeyWithAnnotationOverrides.java
index 028c9c9c6..bcaf57f4a 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/TestCaoCompositeKeyWithAnnotationOverrides.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/TestCaoCompositeKeyWithAnnotationOverrides.java
@@ -1,17 +1,17 @@
 package org.tests.compositekeys;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.compositekeys.db.CaoBean;
 import org.tests.compositekeys.db.CaoKey;
-import org.junit.Test;
 
 public class TestCaoCompositeKeyWithAnnotationOverrides extends BaseTestCase {
 
   @Test
   public void test() {
 
-    Ebean.deleteAll(Ebean.find(CaoBean.class).findList());
+    DB.deleteAll(DB.find(CaoBean.class).findList());
 
     CaoKey key = new CaoKey();
     key.setCustomer(123);
@@ -21,7 +21,7 @@ public class TestCaoCompositeKeyWithAnnotationOverrides extends BaseTestCase {
     bean.setKey(key);
     bean.setDescription("some desc");
 
-    Ebean.save(bean);
+    DB.save(bean);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/TestCore.java b/ebean-test/src/test/java/org/tests/compositekeys/TestCore.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/compositekeys/TestCore.java
rename to ebean-test/src/test/java/org/tests/compositekeys/TestCore.java
index 0a1f96500..6004c8762 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/TestCore.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/TestCore.java
@@ -1,25 +1,18 @@
 package org.tests.compositekeys;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.Transaction;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.tests.compositekeys.db.Item;
-import org.tests.compositekeys.db.ItemKey;
-import org.tests.compositekeys.db.Region;
-import org.tests.compositekeys.db.RegionKey;
-import org.tests.compositekeys.db.SubType;
-import org.tests.compositekeys.db.SubTypeKey;
-import org.tests.compositekeys.db.Type;
-import org.tests.compositekeys.db.TypeKey;
-
-import static org.junit.Assert.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.tests.compositekeys.db.*;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 /**
  * Test some of the Avaje core functionality in conjunction with composite keys like
  * <ul>
@@ -29,13 +22,12 @@ import java.util.List;
  */
 public class TestCore extends BaseTestCase {
 
-  @Before
+  @BeforeEach
   public void setUp() throws Exception {
-
-    Ebean.createUpdate(Item.class, "delete from Item").execute();
-    Ebean.createUpdate(Region.class, "delete from Region").execute();
-    Ebean.createUpdate(Type.class, "delete from Type").execute();
-    Ebean.createUpdate(SubType.class, "delete from SubType").execute();
+    DB.createUpdate(Item.class, "delete from Item").execute();
+    DB.createUpdate(Region.class, "delete from Region").execute();
+    DB.createUpdate(Type.class, "delete from Type").execute();
+    DB.createUpdate(SubType.class, "delete from SubType").execute();
 
     try (Transaction tx = server().beginTransaction()) {
       SubType subType = new SubType();
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/TestOnCascadeDeleteChildrenWithCompositeKeys.java b/ebean-test/src/test/java/org/tests/compositekeys/TestOnCascadeDeleteChildrenWithCompositeKeys.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/compositekeys/TestOnCascadeDeleteChildrenWithCompositeKeys.java
rename to ebean-test/src/test/java/org/tests/compositekeys/TestOnCascadeDeleteChildrenWithCompositeKeys.java
index 358c1c8e0..e637a0465 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/TestOnCascadeDeleteChildrenWithCompositeKeys.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/TestOnCascadeDeleteChildrenWithCompositeKeys.java
@@ -1,30 +1,22 @@
 package org.tests.compositekeys;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.Identity;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Embeddable;
-import javax.persistence.EmbeddedId;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 
 import static io.ebean.annotation.IdentityGenerated.BY_DEFAULT;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * Read more at https://groups.google.com/forum/#!topic/ebean/VD1MV2-LrOc
@@ -32,15 +24,15 @@ import static org.junit.Assert.assertEquals;
 public class TestOnCascadeDeleteChildrenWithCompositeKeys extends BaseTestCase {
 
 
-  @Before
+  @BeforeEach
   public void before() {
 
     // remove all the User records first
-    Ebean.deleteAll(Ebean.find(User.class).findList());
+    DB.deleteAll(DB.find(User.class).findList());
 
     // insert 2 User records
-    Ebean.save(new User(1L, "one"));
-    Ebean.save(new User(2L, "two"));
+    DB.save(new User(1L, "one"));
+    DB.save(new User(2L, "two"));
   }
 
   /**
@@ -49,10 +41,10 @@ public class TestOnCascadeDeleteChildrenWithCompositeKeys extends BaseTestCase {
   @Test
   public void testDeleteById() {
 
-    assertEquals(2, Ebean.find(User.class).findList().size());
-    Ebean.delete(User.class, 1L);
-    Ebean.delete(User.class, 2L);
-    assertEquals(0, Ebean.find(User.class).findList().size());
+    assertEquals(2, DB.find(User.class).findList().size());
+    DB.delete(User.class, 1L);
+    DB.delete(User.class, 2L);
+    assertEquals(0, DB.find(User.class).findList().size());
   }
 
   /**
@@ -62,26 +54,26 @@ public class TestOnCascadeDeleteChildrenWithCompositeKeys extends BaseTestCase {
   @Test
   public void testDeleteByIdList() {
 
-    assertEquals(2, Ebean.find(User.class).findList().size());
+    assertEquals(2, DB.find(User.class).findList().size());
     List<Long> ids = new ArrayList<>();
     ids.add(1L);
     ids.add(2L);
 
-    Ebean.deleteAll(User.class, ids); // PersistenceException would be thrown here
-    assertEquals(0, Ebean.find(User.class).findList().size());
+    DB.deleteAll(User.class, ids); // PersistenceException would be thrown here
+    assertEquals(0, DB.find(User.class).findList().size());
   }
 
   @Test
   public void testFindByParentIdList() {
 
-    assertEquals(2, Ebean.find(User.class).findList().size());
+    assertEquals(2, DB.find(User.class).findList().size());
 
-    SpiEbeanServer spiServer = (SpiEbeanServer) Ebean.getServer(null);
+    SpiEbeanServer spiServer = (SpiEbeanServer) DB.getDefault();
 
     BeanDescriptor<TestOnCascadeDeleteChildrenWithCompositeKeys.User> beanDescriptor =
-      spiServer.getBeanDescriptor(TestOnCascadeDeleteChildrenWithCompositeKeys.User.class);
+      spiServer.descriptor(TestOnCascadeDeleteChildrenWithCompositeKeys.User.class);
 
-    BeanPropertyAssocMany<?> beanProperty = (BeanPropertyAssocMany<?>) beanDescriptor.getBeanProperty("userRoles");
+    BeanPropertyAssocMany<?> beanProperty = (BeanPropertyAssocMany<?>) beanDescriptor.beanProperty("userRoles");
 
     List<Object> ids = new ArrayList<>();
     ids.add(1L);
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/AuditInfo.java b/ebean-test/src/test/java/org/tests/compositekeys/db/AuditInfo.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/AuditInfo.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/AuditInfo.java
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/CaoBean.java b/ebean-test/src/test/java/org/tests/compositekeys/db/CaoBean.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/CaoBean.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/CaoBean.java
index 441035b6a..8638fe610 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/db/CaoBean.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/db/CaoBean.java
@@ -1,10 +1,6 @@
 package org.tests.compositekeys.db;
 
-import javax.persistence.AttributeOverride;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class CaoBean {
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/CaoKey.java b/ebean-test/src/test/java/org/tests/compositekeys/db/CaoKey.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/CaoKey.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/CaoKey.java
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/Item.java b/ebean-test/src/test/java/org/tests/compositekeys/db/Item.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/Item.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/Item.java
index 1b0aa526b..9aca96574 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/db/Item.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/db/Item.java
@@ -1,13 +1,6 @@
 package org.tests.compositekeys.db;
 
-import javax.persistence.AttributeOverride;
-import javax.persistence.Column;
-import javax.persistence.Embedded;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class Item {
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/ItemKey.java b/ebean-test/src/test/java/org/tests/compositekeys/db/ItemKey.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/ItemKey.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/ItemKey.java
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/Parcel.java b/ebean-test/src/test/java/org/tests/compositekeys/db/Parcel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/Parcel.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/Parcel.java
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/ParcelLocation.java b/ebean-test/src/test/java/org/tests/compositekeys/db/ParcelLocation.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/ParcelLocation.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/ParcelLocation.java
index b9822b807..79d541673 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/db/ParcelLocation.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/db/ParcelLocation.java
@@ -1,10 +1,6 @@
 package org.tests.compositekeys.db;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.OneToOne;
+import javax.persistence.*;
 
 @Entity
 public class ParcelLocation {
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/Region.java b/ebean-test/src/test/java/org/tests/compositekeys/db/Region.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/Region.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/Region.java
index e75aae7de..be0891ac8 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/db/Region.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/db/Region.java
@@ -1,11 +1,6 @@
 package org.tests.compositekeys.db;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinColumns;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/RegionKey.java b/ebean-test/src/test/java/org/tests/compositekeys/db/RegionKey.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/RegionKey.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/RegionKey.java
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/SubType.java b/ebean-test/src/test/java/org/tests/compositekeys/db/SubType.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/SubType.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/SubType.java
index 4cbe63fec..a6defdc4e 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/db/SubType.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/db/SubType.java
@@ -1,7 +1,6 @@
 package org.tests.compositekeys.db;
 
 import io.ebean.annotation.Identity;
-import io.ebean.annotation.IdentityGenerated;
 
 import javax.persistence.EmbeddedId;
 import javax.persistence.Entity;
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/SubTypeKey.java b/ebean-test/src/test/java/org/tests/compositekeys/db/SubTypeKey.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/SubTypeKey.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/SubTypeKey.java
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/Type.java b/ebean-test/src/test/java/org/tests/compositekeys/db/Type.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/Type.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/Type.java
index 298d6bc4b..bfd160d98 100644
--- a/ebean-core/src/test/java/org/tests/compositekeys/db/Type.java
+++ b/ebean-test/src/test/java/org/tests/compositekeys/db/Type.java
@@ -1,13 +1,6 @@
 package org.tests.compositekeys.db;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinColumns;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/compositekeys/db/TypeKey.java b/ebean-test/src/test/java/org/tests/compositekeys/db/TypeKey.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/compositekeys/db/TypeKey.java
rename to ebean-test/src/test/java/org/tests/compositekeys/db/TypeKey.java
diff --git a/ebean-core/src/test/java/org/tests/contructor/TestProtectedConstructor.java b/ebean-test/src/test/java/org/tests/contructor/TestProtectedConstructor.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/contructor/TestProtectedConstructor.java
rename to ebean-test/src/test/java/org/tests/contructor/TestProtectedConstructor.java
index 44f0175b8..9a90095bf 100644
--- a/ebean-core/src/test/java/org/tests/contructor/TestProtectedConstructor.java
+++ b/ebean-test/src/test/java/org/tests/contructor/TestProtectedConstructor.java
@@ -2,23 +2,24 @@ package org.tests.contructor;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.bean.EntityBean;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MProtectedConstructBean;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestProtectedConstructor extends BaseTestCase {
 
   @Test
   public void test() {
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     // check that we can construc a bean with a protected constructor
     MProtectedConstructBean bean = server.createEntityBean(MProtectedConstructBean.class);
-    Assert.assertNotNull(bean);
+    assertNotNull(bean);
 
     // Note1 that the enhancement ClassAdapterEntity line 239 makes a default constructor publically accessible
     // Note2 the ClassAdpater will call DefaultConstructor.add() to add a default constructor if it doesn't exist
@@ -27,10 +28,10 @@ public class TestProtectedConstructor extends BaseTestCase {
     EntityBean entityBean = (EntityBean) bean;
     Object newBeanInstance = entityBean._ebean_newInstance();
 
-    Assert.assertNotNull(newBeanInstance);
-    BeanState beanState = Ebean.getBeanState(newBeanInstance);
-    Assert.assertTrue(beanState.isNew());
-    Assert.assertNotSame(entityBean, newBeanInstance);
+    assertNotNull(newBeanInstance);
+    BeanState beanState = DB.beanState(newBeanInstance);
+    assertTrue(beanState.isNew());
+    assertNotSame(entityBean, newBeanInstance);
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/ddd/iud/TestDExhEntityEl.java b/ebean-test/src/test/java/org/tests/ddd/iud/TestDExhEntityEl.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/ddd/iud/TestDExhEntityEl.java
rename to ebean-test/src/test/java/org/tests/ddd/iud/TestDExhEntityEl.java
index 92aaab8de..c3b0a09c2 100644
--- a/ebean-core/src/test/java/org/tests/ddd/iud/TestDExhEntityEl.java
+++ b/ebean-test/src/test/java/org/tests/ddd/iud/TestDExhEntityEl.java
@@ -1,9 +1,10 @@
 package org.tests.ddd.iud;
 
-import junit.framework.TestCase;
+import org.junit.jupiter.api.Test;
 
-public class TestDExhEntityEl extends TestCase {
+public class TestDExhEntityEl {
 
+  @Test
   public void test() {
 
 //        GlobalProperties.put("classes", DExhEntity.class.toString());
@@ -18,7 +19,7 @@ public class TestDExhEntityEl extends TestCase {
 //        DExhEntity p = new DExhEntity();
 //        p.setExhange(exh);
 //
-//        SpiEbeanServer server = (SpiEbeanServer)Ebean.getServer(null);
+//        SpiEbeanServer server = (SpiEbeanServer)DB.getDefault();
 //
 //        BeanDescriptor<DExhEntity> descriptor = server.getBeanDescriptor(DExhEntity.class);
 //
diff --git a/ebean-core/src/test/java/org/tests/ddd/iud/TestDPersonEl.java b/ebean-test/src/test/java/org/tests/ddd/iud/TestDPersonEl.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/ddd/iud/TestDPersonEl.java
rename to ebean-test/src/test/java/org/tests/ddd/iud/TestDPersonEl.java
index 237b4c66b..e01f736f8 100644
--- a/ebean-core/src/test/java/org/tests/ddd/iud/TestDPersonEl.java
+++ b/ebean-test/src/test/java/org/tests/ddd/iud/TestDPersonEl.java
@@ -1,20 +1,21 @@
 package org.tests.ddd.iud;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.EntityBean;
 import io.ebean.plugin.BeanType;
 import io.ebean.plugin.ExpressionPath;
 import io.ebean.plugin.SpiServer;
 import io.ebean.text.json.JsonContext;
+import org.junit.jupiter.api.Test;
 import org.tests.model.ddd.DPerson;
 import org.tests.model.ivo.Money;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.Currency;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestDPersonEl {
 
@@ -23,17 +24,17 @@ public class TestDPersonEl {
 
     Currency NZD = Currency.getInstance("NZD");
     assertThat(NZD).isNotNull();
-    
+
     DPerson p = new DPerson();
     p.setFirstName("first");
     p.setLastName("last");
     p.setSalary(new Money("12200"));
 
-    Ebean.save(p);
+    DB.save(p);
 
-    SpiServer server = Ebean.getDefaultServer().getPluginApi();
+    SpiServer server = DB.getDefault().pluginApi();
 
-    BeanType<DPerson> descriptor = server.getBeanType(DPerson.class);
+    BeanType<DPerson> descriptor = server.beanType(DPerson.class);
 
 
     JsonContext jsonContext = server.json();
@@ -46,7 +47,7 @@ public class TestDPersonEl {
 
     EntityBean entityBean = (EntityBean) p;
 
-    ExpressionPath elSalary = descriptor.getExpressionPath("salary");
+    ExpressionPath elSalary = descriptor.expressionPath("salary");
 
     Object money = elSalary.pathGet(entityBean);
 
diff --git a/ebean-core/src/test/java/org/tests/ddd/iud/TestDPersonIUD.java b/ebean-test/src/test/java/org/tests/ddd/iud/TestDPersonIUD.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/ddd/iud/TestDPersonIUD.java
rename to ebean-test/src/test/java/org/tests/ddd/iud/TestDPersonIUD.java
index 2992a533d..686363fe9 100644
--- a/ebean-core/src/test/java/org/tests/ddd/iud/TestDPersonIUD.java
+++ b/ebean-test/src/test/java/org/tests/ddd/iud/TestDPersonIUD.java
@@ -1,10 +1,10 @@
 package org.tests.ddd.iud;
 
-import junit.framework.TestCase;
-
-public class TestDPersonIUD extends TestCase {
+import org.junit.jupiter.api.Test;
 
+public class TestDPersonIUD {
 
+  @Test
   public void test() {
 
 //        GlobalProperties.put("classes", DPerson.class.toString());
@@ -19,12 +19,12 @@ public class TestDPersonIUD extends TestCase {
 //
 //        p.setInterval(new Interval(System.currentTimeMillis()-20000, System.currentTimeMillis()));
 //
-//        Ebean.save(p);
+//        DB.save(p);
 //
 //        Oid<DPerson> id = p.getId();
 //        Assert.assertNotNull(id);
 //
-//        DPerson p2 = Ebean.find(DPerson.class)
+//        DPerson p2 = DB.find(DPerson.class)
 //            .setAutoTune(false)
 //            .where().idEq(id)
 //            .findOne();
@@ -37,7 +37,7 @@ public class TestDPersonIUD extends TestCase {
 //        Assert.assertEquals(NZD, p2.getCmoney().getCurrency());
 //
 //
-//        Query<DPerson> query = Ebean.find(DPerson.class)
+//        Query<DPerson> query = DB.find(DPerson.class)
 //            .setAutoTune(false)
 //            .where().gt("cmoney.amount",1)
 //            .query();
diff --git a/ebean-core/src/test/java/org/tests/ddl/DfkCascade.java b/ebean-test/src/test/java/org/tests/ddl/DfkCascade.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/ddl/DfkCascade.java
rename to ebean-test/src/test/java/org/tests/ddl/DfkCascade.java
diff --git a/ebean-core/src/test/java/org/tests/ddl/DfkCascadeOne.java b/ebean-test/src/test/java/org/tests/ddl/DfkCascadeOne.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/ddl/DfkCascadeOne.java
rename to ebean-test/src/test/java/org/tests/ddl/DfkCascadeOne.java
diff --git a/ebean-core/src/test/java/org/tests/ddl/DfkNone.java b/ebean-test/src/test/java/org/tests/ddl/DfkNone.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/ddl/DfkNone.java
rename to ebean-test/src/test/java/org/tests/ddl/DfkNone.java
diff --git a/ebean-core/src/test/java/org/tests/ddl/DfkNoneViaJoin.java b/ebean-test/src/test/java/org/tests/ddl/DfkNoneViaJoin.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/ddl/DfkNoneViaJoin.java
rename to ebean-test/src/test/java/org/tests/ddl/DfkNoneViaJoin.java
index 148e219b9..5d95be203 100644
--- a/ebean-core/src/test/java/org/tests/ddl/DfkNoneViaJoin.java
+++ b/ebean-test/src/test/java/org/tests/ddl/DfkNoneViaJoin.java
@@ -1,11 +1,6 @@
 package org.tests.ddl;
 
-import javax.persistence.ConstraintMode;
-import javax.persistence.Entity;
-import javax.persistence.ForeignKey;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 
 @Entity
 public class DfkNoneViaJoin {
diff --git a/ebean-core/src/test/java/org/tests/ddl/DfkNoneViaMtoM.java b/ebean-test/src/test/java/org/tests/ddl/DfkNoneViaMtoM.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/ddl/DfkNoneViaMtoM.java
rename to ebean-test/src/test/java/org/tests/ddl/DfkNoneViaMtoM.java
diff --git a/ebean-core/src/test/java/org/tests/ddl/DfkOne.java b/ebean-test/src/test/java/org/tests/ddl/DfkOne.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/ddl/DfkOne.java
rename to ebean-test/src/test/java/org/tests/ddl/DfkOne.java
diff --git a/ebean-core/src/test/java/org/tests/ddl/DfkSetNull.java b/ebean-test/src/test/java/org/tests/ddl/DfkSetNull.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/ddl/DfkSetNull.java
rename to ebean-test/src/test/java/org/tests/ddl/DfkSetNull.java
diff --git a/ebean-core/src/test/java/org/tests/ddl/TestForeignKeyModes.java b/ebean-test/src/test/java/org/tests/ddl/TestForeignKeyModes.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/ddl/TestForeignKeyModes.java
rename to ebean-test/src/test/java/org/tests/ddl/TestForeignKeyModes.java
index f6f2ee64e..8986ba8e8 100644
--- a/ebean-core/src/test/java/org/tests/ddl/TestForeignKeyModes.java
+++ b/ebean-test/src/test/java/org/tests/ddl/TestForeignKeyModes.java
@@ -1,11 +1,11 @@
 package org.tests.ddl;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -17,15 +17,15 @@ public class TestForeignKeyModes extends BaseTestCase {
   public void none() {
 
     DfkOne one = new DfkOne("one");
-    Ebean.save(one);
+    DB.save(one);
 
     DfkNone none = new DfkNone("none", one);
-    Ebean.save(none);
+    DB.save(none);
 
     // fails unless there is no Foreign key ...
-    Ebean.delete(one);
+    DB.delete(one);
 
-    DfkNone found = Ebean.find(DfkNone.class, none.getId());
+    DfkNone found = DB.find(DfkNone.class, none.getId());
     assertThat(found).isNotNull();
     // we still reference one ... even though it does not exist anymore
     assertThat(found.getOne()).isNotNull();
@@ -36,15 +36,15 @@ public class TestForeignKeyModes extends BaseTestCase {
   public void noneViaJoin() {
 
     DfkOne one = new DfkOne("one2");
-    Ebean.save(one);
+    DB.save(one);
 
     DfkNoneViaJoin none = new DfkNoneViaJoin("none2", one);
-    Ebean.save(none);
+    DB.save(none);
 
     // fails unless there is no Foreign key ...
-    Ebean.delete(one);
+    DB.delete(one);
 
-    DfkNoneViaJoin found = Ebean.find(DfkNoneViaJoin.class, none.getId());
+    DfkNoneViaJoin found = DB.find(DfkNoneViaJoin.class, none.getId());
     assertThat(found).isNotNull();
     // we still reference one ... even though it does not exist anymore
     assertThat(found.getOne()).isNotNull();
@@ -53,7 +53,7 @@ public class TestForeignKeyModes extends BaseTestCase {
   @Test
   public void noneViaManyToMany() {
 
-    DfkOne one = Ebean.getReference(DfkOne.class, 999L);
+    DfkOne one = DB.reference(DfkOne.class, 999L);
 
     DfkNoneViaMtoM none = new DfkNoneViaMtoM("none2");
     none.getOnes().add(one);
@@ -61,9 +61,9 @@ public class TestForeignKeyModes extends BaseTestCase {
     // Would normally fail as DfkOne id:999 is not actually in Database
     // and with the foreign key constraint on the intersection table the
     // insert into the intersection table would fail
-    Ebean.save(none);
+    DB.save(none);
 
-    DfkNoneViaMtoM found = Ebean.find(DfkNoneViaMtoM.class)
+    DfkNoneViaMtoM found = DB.find(DfkNoneViaMtoM.class)
       .setId(none.getId())
       .fetch("ones", "id")
       .findOne();
@@ -75,10 +75,10 @@ public class TestForeignKeyModes extends BaseTestCase {
     assertThat(found.getOnes()).isNotNull();
     assertThat(found.getOnes()).hasSize(0);
 
-    LoggedSqlCollector.start();
-    Ebean.delete(none);
+    LoggedSql.start();
+    DB.delete(none);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("delete from dfk_none_via_mto_m_dfk_one where dfk_none_via_mto_m_id = ?");
     assertSqlBind(sql.get(1));
@@ -90,15 +90,15 @@ public class TestForeignKeyModes extends BaseTestCase {
   public void setNullOnDelete() {
 
     DfkOne one = new DfkOne("one2");
-    Ebean.save(one);
+    DB.save(one);
 
     DfkSetNull other = new DfkSetNull("none", one);
-    Ebean.save(other);
+    DB.save(other);
 
     // success with ... fkey value set to null
-    Ebean.delete(one);
+    DB.delete(one);
 
-    DfkSetNull found = Ebean.find(DfkSetNull.class, other.getId());
+    DfkSetNull found = DB.find(DfkSetNull.class, other.getId());
     assertThat(found).isNotNull();
     assertThat(found.getOne()).isNull();
   }
@@ -115,18 +115,18 @@ public class TestForeignKeyModes extends BaseTestCase {
     one.getDetails().add(new DfkCascade("cascade2", one));
     one.getDetails().add(new DfkCascade("cascade3", one));
 
-    Ebean.save(one);
+    DB.save(one);
 
 
-    LoggedSqlCollector.start();
-    Ebean.delete(one);
+    LoggedSql.start();
+    DB.delete(one);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("delete from dfk_cascade_one where id=?");
 
-    DfkCascade found = Ebean.find(DfkCascade.class, other.getId());
+    DfkCascade found = DB.find(DfkCascade.class, other.getId());
     assertThat(found).isNull();
 
   }
diff --git a/ebean-core/src/test/java/org/tests/defaultvalues/DefaultsModel.java b/ebean-test/src/test/java/org/tests/defaultvalues/DefaultsModel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/defaultvalues/DefaultsModel.java
rename to ebean-test/src/test/java/org/tests/defaultvalues/DefaultsModel.java
diff --git a/ebean-core/src/test/java/org/tests/defaultvalues/ReferencedDefaultsModel.java b/ebean-test/src/test/java/org/tests/defaultvalues/ReferencedDefaultsModel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/defaultvalues/ReferencedDefaultsModel.java
rename to ebean-test/src/test/java/org/tests/defaultvalues/ReferencedDefaultsModel.java
diff --git a/ebean-core/src/test/java/org/tests/defaultvalues/TestDefaults.java b/ebean-test/src/test/java/org/tests/defaultvalues/TestDefaults.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/defaultvalues/TestDefaults.java
rename to ebean-test/src/test/java/org/tests/defaultvalues/TestDefaults.java
index a5f7affb2..828fc2b35 100644
--- a/ebean-core/src/test/java/org/tests/defaultvalues/TestDefaults.java
+++ b/ebean-test/src/test/java/org/tests/defaultvalues/TestDefaults.java
@@ -1,9 +1,9 @@
 package org.tests.defaultvalues;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -21,9 +21,9 @@ public class TestDefaults extends BaseTestCase {
       main.getRelatedModels().add(ref);
     }
 
-    LoggedSqlCollector.start();
-    Ebean.save(main);
-    final List<String> current = LoggedSqlCollector.current();
+    LoggedSql.start();
+    DB.save(main);
+    final List<String> current = LoggedSql.collect();
 
     assertThat(current).isNotEmpty();
     if (isMySql() || isMariaDB()) {
diff --git a/ebean-core/src/test/java/org/tests/delete/DcDetail.java b/ebean-test/src/test/java/org/tests/delete/DcDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/delete/DcDetail.java
rename to ebean-test/src/test/java/org/tests/delete/DcDetail.java
diff --git a/ebean-core/src/test/java/org/tests/delete/DcListener.java b/ebean-test/src/test/java/org/tests/delete/DcListener.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/delete/DcListener.java
rename to ebean-test/src/test/java/org/tests/delete/DcListener.java
diff --git a/ebean-core/src/test/java/org/tests/delete/DcMaster.java b/ebean-test/src/test/java/org/tests/delete/DcMaster.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/delete/DcMaster.java
rename to ebean-test/src/test/java/org/tests/delete/DcMaster.java
index e1c8d0144..22a0e1b3a 100644
--- a/ebean-core/src/test/java/org/tests/delete/DcMaster.java
+++ b/ebean-test/src/test/java/org/tests/delete/DcMaster.java
@@ -1,10 +1,6 @@
 package org.tests.delete;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/delete/TestDeleteByIdUsingModel.java b/ebean-test/src/test/java/org/tests/delete/TestDeleteByIdUsingModel.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/delete/TestDeleteByIdUsingModel.java
rename to ebean-test/src/test/java/org/tests/delete/TestDeleteByIdUsingModel.java
index c0a63888b..dc563f1a2 100644
--- a/ebean-core/src/test/java/org/tests/delete/TestDeleteByIdUsingModel.java
+++ b/ebean-test/src/test/java/org/tests/delete/TestDeleteByIdUsingModel.java
@@ -1,11 +1,11 @@
 package org.tests.delete;
 
 import io.ebean.BaseTestCase;
+import org.junit.jupiter.api.Test;
 import org.tests.model.onetoone.Account;
-import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestDeleteByIdUsingModel extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/delete/TestDeleteByIdWithPersistenceContext.java b/ebean-test/src/test/java/org/tests/delete/TestDeleteByIdWithPersistenceContext.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/delete/TestDeleteByIdWithPersistenceContext.java
rename to ebean-test/src/test/java/org/tests/delete/TestDeleteByIdWithPersistenceContext.java
index 6858e12d4..d773c010e 100644
--- a/ebean-core/src/test/java/org/tests/delete/TestDeleteByIdWithPersistenceContext.java
+++ b/ebean-test/src/test/java/org/tests/delete/TestDeleteByIdWithPersistenceContext.java
@@ -1,16 +1,17 @@
 package org.tests.delete;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.Transaction;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Product;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.Arrays;
 
+import static org.junit.jupiter.api.Assertions.assertNull;
+
 public class TestDeleteByIdWithPersistenceContext extends BaseTestCase {
 
   @Test
@@ -18,10 +19,10 @@ public class TestDeleteByIdWithPersistenceContext extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Ebean.delete(Product.class, 100);
-    Ebean.delete(Product.class, 101);
+    DB.delete(Product.class, 100);
+    DB.delete(Product.class, 101);
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
     Product prod1 = createProduct(100, "apples");
     server.insert(prod1);
     Product prod2 = createProduct(101, "bananas");
@@ -38,14 +39,13 @@ public class TestDeleteByIdWithPersistenceContext extends BaseTestCase {
       Product shadow1 = server.find(Product.class, prod1.getId());
       Product shadow2 = server.find(Product.class, prod2.getId());
 
-      Assert.assertNull(shadow1);
-      Assert.assertNull(shadow2);
-
+      assertNull(shadow1);
+      assertNull(shadow2);
     }
 
     // cleanup
-    Ebean.delete(Product.class, 100);
-    Ebean.delete(Product.class, 101);
+    DB.delete(Product.class, 100);
+    DB.delete(Product.class, 101);
   }
 
   private Product createProduct(Integer id, String name) {
diff --git a/ebean-core/src/test/java/org/tests/delete/TestDeleteByQuery.java b/ebean-test/src/test/java/org/tests/delete/TestDeleteByQuery.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/delete/TestDeleteByQuery.java
rename to ebean-test/src/test/java/org/tests/delete/TestDeleteByQuery.java
index 7ef161e5f..4e826b584 100644
--- a/ebean-core/src/test/java/org/tests/delete/TestDeleteByQuery.java
+++ b/ebean-test/src/test/java/org/tests/delete/TestDeleteByQuery.java
@@ -1,19 +1,11 @@
 package org.tests.delete;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.Database;
-import io.ebean.Query;
-import io.ebean.Transaction;
+import io.ebean.*;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
-import org.tests.model.basic.BBookmarkUser;
-import org.tests.model.basic.Contact;
-import org.tests.model.basic.Country;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.ResetBasicData;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 
@@ -34,7 +26,7 @@ public class TestDeleteByQuery extends BaseTestCase {
     createUser("deleteWithLimit3");
     createUser("deleteWithLimit4");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     final int rows = DB.find(BBookmarkUser.class)
       .where().startsWith("name", "deleteWithLimit")
       .setMaxRows(3)
@@ -42,7 +34,7 @@ public class TestDeleteByQuery extends BaseTestCase {
 
     assertThat(rows).isEqualTo(3);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     if (isSqlServer()) {
       assertSql(sql.get(0)).contains("delete from bbookmark_user where id in (select top 3 t0.id from bbookmark_user t0 where t0.name like ");
     } else {
@@ -74,20 +66,20 @@ public class TestDeleteByQuery extends BaseTestCase {
       .where().eq("org.name", "NahYeahMaybe")
       .query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.delete();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(trimSql(loggedSql.get(0), 1)).contains("delete from bbookmark_user where id in (select t0.id from bbookmark_user t0 left join bbookmark_org t1 on t1.id = t0.org_id where t1.name");
 
     Query<BBookmarkUser> query2 = server.find(BBookmarkUser.class)
       .where().eq("name", "NotARealFirstName").query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query2.delete();
 
-    loggedSql = LoggedSqlCollector.stop();
+    loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     if (isPlatformSupportsDeleteTableAlias()) {
       assertThat(loggedSql.get(0)).contains("delete from bbookmark_user t0 where t0.name =");
@@ -114,19 +106,19 @@ public class TestDeleteByQuery extends BaseTestCase {
 
     Query<Contact> query = server.find(Contact.class).where().eq("group.name", "NahYeahMaybe").query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.delete();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(trimSql(loggedSql.get(0), 1)).contains("select t0.id from contact t0 left join contact_group t1 on t1.id = t0.group_id where t1.name = ?");
 
     Query<Contact> query2 = server.find(Contact.class).where().eq("firstName", "NotARealFirstName").query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query2.delete();
 
-    loggedSql = LoggedSqlCollector.stop();
+    loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("select t0.id from contact t0 where t0.first_name = ?");
 
@@ -141,12 +133,12 @@ public class TestDeleteByQuery extends BaseTestCase {
   @Test
   public void queryByIdDelete() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.find(BBookmarkUser.class).where().eq("id", 7000).delete();
     DB.find(BBookmarkUser.class).setId(7000).delete();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     if (isPlatformSupportsDeleteTableAlias()) {
       assertSql(sql.get(0)).contains("delete from bbookmark_user t0 where t0.id = ?");
       assertSql(sql.get(1)).contains("delete from bbookmark_user t0 where t0.id = ?");
@@ -162,12 +154,12 @@ public class TestDeleteByQuery extends BaseTestCase {
   @Test
   public void queryByIdDelete_withEscalation() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.find(Contact.class).where().eq("id", 7000).delete();
     DB.find(Contact.class).setId(7000).delete();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     // escalate to fetch ids then delete ... but no rows found
     assertSql(sql.get(0)).contains("select t0.id from contact t0 where t0.id = ?");
     assertSql(sql.get(1)).contains("select t0.id from contact t0 where t0.id = ?");
@@ -179,7 +171,7 @@ public class TestDeleteByQuery extends BaseTestCase {
   @Test
   public void queryDelete_withTransactionNoCascade() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     try (Transaction transaction = DB.beginTransaction()) {
       transaction.setPersistCascade(false);
@@ -189,7 +181,7 @@ public class TestDeleteByQuery extends BaseTestCase {
       transaction.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     if (isPlatformSupportsDeleteTableAlias()) {
       assertSql(sql.get(0)).contains("delete from contact t0 where t0.id = ?");
     } else if (!isMySql()){
@@ -200,14 +192,14 @@ public class TestDeleteByQuery extends BaseTestCase {
   @Test
   public void testWithForUpdate() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.find(Customer.class)
       .where().eq("name", "Don Roberto")
       .query().forUpdate()
       .delete();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isSqlServer()) {
       assertSql(sql.get(0)).contains("select t0.id from o_customer t0 with (updlock) where t0.name = ?");
@@ -260,7 +252,7 @@ public class TestDeleteByQuery extends BaseTestCase {
     assertThat(query.findCount()).isEqualTo(1);
 
     DB.find(Country.class).where().eq("name", "SecretName").delete();
-    //Ebean.getDefaultServer().getPluginApi().getBeanType(Country.class).clearQueryCache();
+    //DB.getDefault().getPluginApi().getBeanType(Country.class).clearQueryCache();
     assertThat(query.findList()).hasSize(0);
     assertThat(query.findCount()).isEqualTo(0);
   }
diff --git a/ebean-core/src/test/java/org/tests/delete/TestDeleteCascadeWithListener.java b/ebean-test/src/test/java/org/tests/delete/TestDeleteCascadeWithListener.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/delete/TestDeleteCascadeWithListener.java
rename to ebean-test/src/test/java/org/tests/delete/TestDeleteCascadeWithListener.java
index ccf49f0d7..1b24ee419 100644
--- a/ebean-core/src/test/java/org/tests/delete/TestDeleteCascadeWithListener.java
+++ b/ebean-test/src/test/java/org/tests/delete/TestDeleteCascadeWithListener.java
@@ -1,9 +1,9 @@
 package org.tests.delete;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -19,14 +19,14 @@ public class TestDeleteCascadeWithListener extends BaseTestCase {
     m0.getDetails().add(new DcDetail());
     m0.getDetails().add(new DcDetail());
 
-    Ebean.save(m0);
+    DB.save(m0);
 
-    DcMaster found = Ebean.find(DcMaster.class, m0.getId());
+    DcMaster found = DB.find(DcMaster.class, m0.getId());
 
-    LoggedSqlCollector.start();
-    Ebean.delete(found);
+    LoggedSql.start();
+    DB.delete(found);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(6);
       assertSql(sql.get(0)).contains("select t0.id from dc_detail t0 where master_id=?");
diff --git a/ebean-core/src/test/java/org/tests/delete/TestDeleteWithoutOptimisticLocking.java b/ebean-test/src/test/java/org/tests/delete/TestDeleteWithoutOptimisticLocking.java
similarity index 59%
rename from ebean-core/src/test/java/org/tests/delete/TestDeleteWithoutOptimisticLocking.java
rename to ebean-test/src/test/java/org/tests/delete/TestDeleteWithoutOptimisticLocking.java
index 20eff9e4d..ff6dd9c33 100644
--- a/ebean-core/src/test/java/org/tests/delete/TestDeleteWithoutOptimisticLocking.java
+++ b/ebean-test/src/test/java/org/tests/delete/TestDeleteWithoutOptimisticLocking.java
@@ -1,10 +1,10 @@
 package org.tests.delete;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.Transaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.EBasicVer;
 import org.tests.model.converstation.Group;
@@ -17,13 +17,13 @@ public class TestDeleteWithoutOptimisticLocking extends BaseTestCase {
   public void testSimpleBeanDelete_missingBean_returnsFalse() {
 
     // delete by by without version loaded ... should not throw OptimisticLockException
-    Contact ref = Ebean.getReference(Contact.class, 999999);
-    assertThat(Ebean.delete(ref)).isFalse();
+    Contact ref = DB.reference(Contact.class, 999999);
+    assertThat(DB.delete(ref)).isFalse();
 
-    assertThat(Ebean.delete(Contact.class, 999999)).isEqualTo(0);
+    assertThat(DB.delete(Contact.class, 999999)).isEqualTo(0);
 
     // same as above but using Model.delete()
-    Group modelRef = Ebean.getReference(Group.class, 999999);
+    Group modelRef = DB.reference(Group.class, 999999);
     assertThat(modelRef.delete()).isFalse();
   }
 
@@ -31,10 +31,10 @@ public class TestDeleteWithoutOptimisticLocking extends BaseTestCase {
   public void testSimpleBeanDelete_existingBean_returnsTrue() {
 
     EBasicVer basic = new EBasicVer("DelTest");
-    Ebean.save(basic);
+    DB.save(basic);
 
-    EBasicVer basicRef = Ebean.getReference(EBasicVer.class, basic.getId());
-    assertThat(Ebean.delete(basicRef)).isTrue();
+    EBasicVer basicRef = DB.reference(EBasicVer.class, basic.getId());
+    assertThat(DB.delete(basicRef)).isTrue();
   }
 
 
@@ -42,22 +42,22 @@ public class TestDeleteWithoutOptimisticLocking extends BaseTestCase {
   public void testSimpleBeanDelete_existingBeanWithJdbcBatch_returnsTrue() {
 
     EBasicVer basic = new EBasicVer("DelTestBatch");
-    Ebean.save(basic);
+    DB.save(basic);
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     Transaction transaction = server.beginTransaction();
     try {
       transaction.setBatchMode(true);
 
       // returns true even though the delete has not occurred yet
-      assertThat(server.delete(Ebean.getReference(EBasicVer.class, basic.getId()), transaction)).isTrue();
+      assertThat(server.delete(DB.reference(EBasicVer.class, basic.getId()), transaction)).isTrue();
 
       // returns true even though the bean does not exist
-      assertThat(server.delete(Ebean.getReference(EBasicVer.class, 999999), transaction)).isTrue();
+      assertThat(server.delete(DB.reference(EBasicVer.class, 999999), transaction)).isTrue();
 
       transaction.commit();
 
-      assertThat(Ebean.find(EBasicVer.class, basic.getId())).isNull();
+      assertThat(DB.find(EBasicVer.class, basic.getId())).isNull();
 
     } finally {
       transaction.end();
diff --git a/ebean-core/src/test/java/org/tests/docstore/CustomerReportTest.java b/ebean-test/src/test/java/org/tests/docstore/CustomerReportTest.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/docstore/CustomerReportTest.java
rename to ebean-test/src/test/java/org/tests/docstore/CustomerReportTest.java
index 3668d833f..ecea5c295 100644
--- a/ebean-core/src/test/java/org/tests/docstore/CustomerReportTest.java
+++ b/ebean-test/src/test/java/org/tests/docstore/CustomerReportTest.java
@@ -1,68 +1,61 @@
 package org.tests.docstore;
 
 
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.util.Arrays;
-
-import org.junit.Test;
+import io.ebean.BaseTestCase;
+import io.ebean.text.json.JsonReadOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Product;
 import org.tests.model.basic.ResetBasicData;
 import org.tests.model.docstore.CustomerReport;
 import org.tests.model.docstore.ProductReport;
 
-import io.ebean.BaseTestCase;
-import io.ebean.text.json.JsonReadOptions;
+import java.util.Arrays;
+
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class CustomerReportTest extends BaseTestCase {
-  
-  
-  
+
   @Test
   public void testToJson() throws Exception {
     ResetBasicData.reset();
-    
 
-    
+
+
     String json = server().json().toJson(getCustomerReport());
-    
-    
     assertThat(json).isEqualTo("{\"dtype\":\"CR\",\"friends\":[{\"id\":2},{\"id\":3}],\"customer\":{\"id\":1}}");
   }
-  
-
 
   @Test
   public void testFromJson() throws Exception {
     ResetBasicData.reset();
     String json = "{\"dtype\":\"CR\",\"friends\":[{\"id\":2},{\"id\":3}],\"customer\":{\"id\":1}}";
-    
+
     JsonReadOptions opts = new JsonReadOptions();
     opts.setEnableLazyLoading(true);
     CustomerReport report = server().json().toBean(CustomerReport.class, json, opts);
-   
+
     assertThat(report.getCustomer().getName()).isEqualTo("Rob");
-    
+
     assertThat(report.getFriends().get(0).getName()).isEqualTo("Cust NoAddress");
     assertThat(report.getFriends().get(1).getName()).isEqualTo("Fiona");
   }
 
-  
+
   @Test
   public void testEmbeddedDocs() throws Exception {
     ResetBasicData.reset();
-    
+
     CustomerReport report = getCustomerReport();
     report.getEmbeddedReports().add(getProductReport());
-    
+
     String json = server().json().toJson(report);
-    
+
     assertThat(json).isEqualTo("{\"dtype\":\"CR\","
         + "\"embeddedReports\":[{\"dtype\":\"PR\",\"title\":\"This is a good product\",\"product\":{\"id\":1}}],"
         + "\"friends\":[{\"id\":2},{\"id\":3}],"
         + "\"customer\":{\"id\":1}}");
-    
+
     JsonReadOptions opts = new JsonReadOptions();
     opts.setEnableLazyLoading(true);
     report = server().json().toBean(CustomerReport.class, json, opts);
@@ -70,22 +63,22 @@ public class CustomerReportTest extends BaseTestCase {
     assertThat(ar.getTitle()).isEqualTo("This is a good product");
     assertThat(ar.getProduct().getName()).isEqualTo("Chair");
   }
-  
-  
+
+
   private CustomerReport getCustomerReport() {
-    Customer customer = server().getReference(Customer.class, 1);
-    Customer friend1 = server().getReference(Customer.class, 2);
-    Customer friend2 = server().getReference(Customer.class, 3);
-    
+    Customer customer = server().reference(Customer.class, 1);
+    Customer friend1 = server().reference(Customer.class, 2);
+    Customer friend2 = server().reference(Customer.class, 3);
+
     CustomerReport report = new CustomerReport();
-    
+
     report.setCustomer(customer);
     report.setFriends(Arrays.asList(friend1, friend2));
     return report;
   }
-  
+
   private ProductReport getProductReport() {
-    Product product = server().getReference(Product.class, 1);
+    Product product = server().reference(Product.class, 1);
 
     ProductReport report = new ProductReport();
     report.setTitle("This is a good product");
diff --git a/ebean-core/src/test/java/org/tests/draftable/DocLinkTest.java b/ebean-test/src/test/java/org/tests/draftable/DocLinkTest.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/draftable/DocLinkTest.java
rename to ebean-test/src/test/java/org/tests/draftable/DocLinkTest.java
index 5c698098e..f21d12225 100644
--- a/ebean-core/src/test/java/org/tests/draftable/DocLinkTest.java
+++ b/ebean-test/src/test/java/org/tests/draftable/DocLinkTest.java
@@ -1,11 +1,11 @@
 package org.tests.draftable;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.draftable.Doc;
 import org.tests.model.draftable.Link;
 
@@ -14,7 +14,7 @@ import java.sql.Timestamp;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.fail;
 
 public class DocLinkTest extends BaseTestCase {
 
@@ -24,21 +24,21 @@ public class DocLinkTest extends BaseTestCase {
     Link link1 = new Link("something");
     link1.save();
 
-    Ebean.getDefaultServer().publish(Link.class, link1.getId());
+    DB.getDefault().publish(Link.class, link1.getId());
 
-    Link link = Ebean.find(Link.class)
+    Link link = DB.find(Link.class)
       .setId(link1.getId())
       .select("name")
       .findOne();
 
     assertThat(link).isNotNull();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // no lazy loading is invoked as draft property considered @Transient
     assertThat(link.isDraft()).isFalse();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).isEmpty();
 
   }
@@ -63,7 +63,7 @@ public class DocLinkTest extends BaseTestCase {
     // automatically set asDraft() on lazy loading query
     linkUpdate.getLocation();
 
-    Ebean.deletePermanent(linkUpdate);
+    DB.deletePermanent(linkUpdate);
   }
 
   @Test
@@ -78,7 +78,7 @@ public class DocLinkTest extends BaseTestCase {
     link1.setComment("some change");
     link1.save();
 
-    Ebean.delete(link1);
+    DB.delete(link1);
   }
 
   @Test
@@ -86,10 +86,10 @@ public class DocLinkTest extends BaseTestCase {
 
     Link link1 = new Link("Ld2");
     link1.save();
-    Ebean.getDefaultServer().publish(Link.class, link1.getId());
+    DB.getDefault().publish(Link.class, link1.getId());
 
-    Link link = Ebean.find(Link.class).setId(link1.getId()).asDraft().findOne();
-    Ebean.deletePermanent(link);
+    Link link = DB.find(Link.class).setId(link1.getId()).asDraft().findOne();
+    DB.deletePermanent(link);
   }
 
   @Test
@@ -98,15 +98,15 @@ public class DocLinkTest extends BaseTestCase {
     Link link1 = new Link("Ld2");
     link1.save();
 
-    Link live = Ebean.getDefaultServer().publish(Link.class, link1.getId());
+    Link live = DB.getDefault().publish(Link.class, link1.getId());
 
     try {
-      Ebean.deletePermanent(live);
-      assertTrue("never get here", false);
+      DB.deletePermanent(live);
+      fail("never get here");
 
     } catch (PersistenceException e) {
       // assert nice message when trying to delete live bean
-      assertThat(e.getMessage().contains("Explicit Delete is not allowed on a 'live' bean - only draft beans"));
+      assertThat(e.getMessage()).contains("Explicit Delete is not allowed on a 'live' bean - only draft beans");
     }
   }
 
@@ -115,16 +115,16 @@ public class DocLinkTest extends BaseTestCase {
 
     Link link1 = new Link("Ld2");
     link1.save();
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     server.publish(Link.class, link1.getId());
 
-    link1 = Ebean.find(Link.class).setId(link1.getId()).asDraft().findOne();
+    link1 = DB.find(Link.class).setId(link1.getId()).asDraft().findOne();
     assertThat(link1.isDraft()).isTrue();
 
     // this is a soft delete (no automatic publish here, only updates draft)
     link1.delete();
 
-    Link live = Ebean.find(Link.class).setId(link1.getId()).findOne();
+    Link live = DB.find(Link.class).setId(link1.getId()).findOne();
     assertThat(live).isNotNull();
     assertThat(live.isDraft()).isFalse();
     assertThat(live.isDeleted()).isFalse(); // soft delete state not published yet
@@ -132,7 +132,7 @@ public class DocLinkTest extends BaseTestCase {
     // this is a permanent delete (effectively has automatic publish)
     server.deletePermanent(link1);
 
-    live = Ebean.find(Link.class).setId(link1.getId()).findOne();
+    live = DB.find(Link.class).setId(link1.getId()).findOne();
     assertThat(live).isNull();
   }
 
@@ -142,13 +142,13 @@ public class DocLinkTest extends BaseTestCase {
     Link link1 = new Link("forUpdateLive");
     link1.save();
 
-    Link live = Ebean.getDefaultServer().publish(Link.class, link1.getId());
+    Link live = DB.getDefault().publish(Link.class, link1.getId());
 
     live.setComment("foo");
     // Expect a nice
     try {
       live.save();
-      assertTrue("Never get here", false);
+      fail("Never get here");
 
     } catch (PersistenceException e) {
       // we want to assert the message is nice and meaningful (and not a optimistic locking exception etc)
@@ -158,7 +158,6 @@ public class DocLinkTest extends BaseTestCase {
 
   @Test
   public void testDirtyState() {
-
     Timestamp when = new Timestamp(System.currentTimeMillis());
     String comment = "Really interesting";
 
@@ -167,16 +166,16 @@ public class DocLinkTest extends BaseTestCase {
     link1.setWhenPublish(when);
     link1.save();
 
-    Link draft1 = Ebean.find(Link.class).setId(link1.getId()).asDraft().findOne();
+    Link draft1 = DB.find(Link.class).setId(link1.getId()).asDraft().findOne();
     assertThat(draft1.isDirty()).isTrue();
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     Link linkLive = server.publish(Link.class, link1.getId(), null);
     assertThat(linkLive.getComment()).isEqualTo(comment);
     assertThat(linkLive.getWhenPublish()).isEqualToIgnoringMillis(when);
 
-    Link draft1b = Ebean.find(Link.class).setId(link1.getId()).asDraft().findOne();
+    Link draft1b = DB.find(Link.class).setId(link1.getId()).asDraft().findOne();
     assertThat(draft1b.isDirty()).isFalse();
     assertThat(draft1b.getComment()).isNull();
     assertThat(draft1b.getWhenPublish()).isNull();
@@ -194,7 +193,7 @@ public class DocLinkTest extends BaseTestCase {
     Link link3 = new Link("LinkThree");
     link3.save();
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     server.publish(Link.class, link1.getId(), null);
     server.publish(Link.class, link2.getId(), null);
     server.publish(Link.class, link3.getId(), null);
@@ -240,12 +239,12 @@ public class DocLinkTest extends BaseTestCase {
     link1.setLocation("firstLocation");
     link1.save();
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     Link live = server.publish(Link.class, link1.getId(), null);
     assertThat(live.isDraft()).isFalse();
 
-    Link draftLink = Ebean.find(Link.class)
+    Link draftLink = DB.find(Link.class)
       .setId(link1.getId())
       .asDraft()
       .findOne();
@@ -255,7 +254,7 @@ public class DocLinkTest extends BaseTestCase {
 
     server.draftRestore(Link.class, link1.getId(), null);
 
-    draftLink = Ebean.find(Link.class)
+    draftLink = DB.find(Link.class)
       .setId(link1.getId())
       .asDraft()
       .findOne();
@@ -271,11 +270,11 @@ public class DocLinkTest extends BaseTestCase {
     link1.setComment("Banana");
     link1.save();
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     server.publish(Link.class, link1.getId(), null);
 
-    Link draftLink = Ebean.find(Link.class)
+    Link draftLink = DB.find(Link.class)
       .setId(link1.getId())
       .asDraft()
       .findOne();
diff --git a/ebean-core/src/test/java/org/tests/draftable/LinkQueryPublishTest.java b/ebean-test/src/test/java/org/tests/draftable/LinkQueryPublishTest.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/draftable/LinkQueryPublishTest.java
rename to ebean-test/src/test/java/org/tests/draftable/LinkQueryPublishTest.java
index 070371ee0..13540041c 100644
--- a/ebean-core/src/test/java/org/tests/draftable/LinkQueryPublishTest.java
+++ b/ebean-test/src/test/java/org/tests/draftable/LinkQueryPublishTest.java
@@ -1,11 +1,11 @@
 package org.tests.draftable;
 
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.PagedList;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.draftable.Link;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -26,7 +26,7 @@ public class LinkQueryPublishTest {
     Link link3 = new Link("L3");
     link3.save();
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     List<Object> ids = new ArrayList<>();
     ids.add(link1.getId());
diff --git a/ebean-core/src/test/java/org/tests/draftable/OrganisationTest.java b/ebean-test/src/test/java/org/tests/draftable/OrganisationTest.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/draftable/OrganisationTest.java
rename to ebean-test/src/test/java/org/tests/draftable/OrganisationTest.java
index 3d2dd4b2c..f3ad2cb00 100644
--- a/ebean-core/src/test/java/org/tests/draftable/OrganisationTest.java
+++ b/ebean-test/src/test/java/org/tests/draftable/OrganisationTest.java
@@ -1,8 +1,8 @@
 package org.tests.draftable;
 
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
 import org.tests.model.draftable.Document;
 import org.tests.model.draftable.DocumentMedia;
 import org.tests.model.draftable.Organisation;
@@ -10,8 +10,8 @@ import org.tests.model.draftable.Organisation;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class OrganisationTest {
 
@@ -34,7 +34,7 @@ public class OrganisationTest {
     doc.save();
 
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     Document draftDoc = server.find(Document.class)
       .asDraft()
@@ -74,18 +74,18 @@ public class OrganisationTest {
     doc.getMedia().add(createMedia("media2"));
     doc.save();
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
 
     server.publish(Document.class, doc.getId(), null);
 
-    Document fetchDoc = Ebean.find(Document.class).setId(doc.getId()).asDraft().findOne();
+    Document fetchDoc = DB.find(Document.class).setId(doc.getId()).asDraft().findOne();
     List<DocumentMedia> media = fetchDoc.getMedia();
 
     assertThat(media.size()).isEqualTo(2);
 
 //    // delete one of the 'child' @DraftElement rows ...
-//    SqlUpdate sqlUpdate = Ebean.createSqlUpdate("delete from document_media_draft where id = ?");
+//    SqlUpdate sqlUpdate = DB.sqlUpdate("delete from document_media_draft where id = ?");
 //    sqlUpdate.setParameter(1, doc.getMedia().get(0).getId());
 //    sqlUpdate.execute();
 
diff --git a/ebean-test/src/test/java/org/tests/el/TestELBasic.java b/ebean-test/src/test/java/org/tests/el/TestELBasic.java
new file mode 100644
index 000000000..9fd4d619b
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/el/TestELBasic.java
@@ -0,0 +1,67 @@
+package org.tests.el;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.*;
+import io.ebeaninternal.server.el.ElPropertyChain;
+import io.ebeaninternal.server.el.ElPropertyDeploy;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Customer;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestELBasic extends BaseTestCase {
+
+  @Test
+  public void testEl() {
+
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
+    BeanDescriptor<Customer> descriptor = server.descriptor(Customer.class);
+
+    ElPropertyDeploy elId = descriptor.elPropertyDeploy("id");
+    assertTrue(elId instanceof BeanProperty);
+
+    ElPropertyDeploy elBillAddress = descriptor.elPropertyDeploy("billingAddress");
+    assertTrue(elBillAddress instanceof BeanPropertyAssocOne<?>);
+
+    ElPropertyDeploy elBillAddressId = descriptor.elPropertyDeploy("billingAddress.id");
+    assertTrue(elBillAddressId instanceof BeanFkeyProperty);
+    assertEquals("billing_address_id", elBillAddressId.dbColumn());
+    assertEquals("billingAddress.id", elBillAddressId.name());
+    assertNull(elBillAddressId.elPrefix());
+
+
+    ElPropertyDeploy elBillAddressCity = descriptor.elPropertyDeploy("billingAddress.city");
+    assertTrue(elBillAddressCity instanceof ElPropertyChain);
+    assertEquals("billingAddress", elBillAddressCity.elPrefix());
+    assertEquals("city", elBillAddressCity.name());
+    assertEquals("${billingAddress}city", elBillAddressCity.elPlaceholder(false));
+    assertEquals("city", elBillAddressCity.dbColumn());
+
+//		ElPropertyDeploy elBillAddressCountry = descriptor.getElPropertyDeploy("billingAddress.country");
+
+
+    ElPropertyDeploy elOrders = descriptor.elPropertyDeploy("orders");
+    assertTrue(elOrders instanceof BeanPropertyAssocMany<?>);
+
+    ElPropertyDeploy elOrderStatus = descriptor.elPropertyDeploy("orders.status");
+    assertTrue(elOrderStatus instanceof ElPropertyChain);
+    assertEquals("orders", elOrderStatus.elPrefix());
+    assertEquals("status", elOrderStatus.name());
+    assertEquals("${orders}status", elOrderStatus.elPlaceholder(false));
+    assertEquals("status", elOrderStatus.dbColumn());
+
+    ElPropertyDeploy elOrderCust = descriptor.elPropertyDeploy("orders.customer");
+    assertTrue(elOrderCust instanceof ElPropertyChain);
+
+    ElPropertyDeploy elOrderDetails = descriptor.elPropertyDeploy("orders.details");
+    assertTrue(elOrderDetails instanceof ElPropertyChain);
+
+    ElPropertyDeploy elOrderDetailsId = descriptor.elPropertyDeploy("orders.details.id");
+    assertTrue(elOrderDetailsId instanceof ElPropertyChain);
+
+  }
+
+
+}
diff --git a/ebean-core/src/test/java/org/tests/el/TestPathExpression.java b/ebean-test/src/test/java/org/tests/el/TestPathExpression.java
similarity index 64%
rename from ebean-core/src/test/java/org/tests/el/TestPathExpression.java
rename to ebean-test/src/test/java/org/tests/el/TestPathExpression.java
index 1fa061269..3c7e87c26 100644
--- a/ebean-core/src/test/java/org/tests/el/TestPathExpression.java
+++ b/ebean-test/src/test/java/org/tests/el/TestPathExpression.java
@@ -1,16 +1,16 @@
 package org.tests.el;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.EntityBean;
 import io.ebean.plugin.BeanType;
 import io.ebean.plugin.ExpressionPath;
 import io.ebean.plugin.SpiServer;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.Customer;
-import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestPathExpression {
 
@@ -20,11 +20,11 @@ public class TestPathExpression {
   final ExpressionPath city;
 
   public TestPathExpression() {
-    SpiServer server = Ebean.getDefaultServer().getPluginApi();
-    beanType = server.getBeanType(Customer.class);
-    billingId = beanType.getExpressionPath("billingAddress.id");
-    line1 = beanType.getExpressionPath("billingAddress.line1");
-    city = beanType.getExpressionPath("billingAddress.city");
+    SpiServer server = DB.getDefault().pluginApi();
+    beanType = server.beanType(Customer.class);
+    billingId = beanType.expressionPath("billingAddress.id");
+    line1 = beanType.expressionPath("billingAddress.line1");
+    city = beanType.expressionPath("billingAddress.city");
   }
 
   @Test
@@ -35,11 +35,11 @@ public class TestPathExpression {
     city.pathSet(c1, "Auckland");
     billingId.pathSet(c1, 4);
 
-    beanType.getExpressionPath("id").pathSet(c1, 42L);
-    beanType.getExpressionPath("name").pathSet(c1, "jimmy");
-    beanType.getExpressionPath("status").pathSet(c1, "ACTIVE");
-    beanType.getExpressionPath("billingAddress.country.code").pathSet(c1, "NZ");
-    beanType.getExpressionPath("billingAddress.country.name").pathSet(c1, "New Zealand");
+    beanType.expressionPath("id").pathSet(c1, 42L);
+    beanType.expressionPath("name").pathSet(c1, "jimmy");
+    beanType.expressionPath("status").pathSet(c1, "ACTIVE");
+    beanType.expressionPath("billingAddress.country.code").pathSet(c1, "NZ");
+    beanType.expressionPath("billingAddress.country.name").pathSet(c1, "New Zealand");
 
 
     assertEquals(c1.getId(), Integer.valueOf(42));
@@ -75,7 +75,7 @@ public class TestPathExpression {
     assertEquals(billingId.pathGet(e0), Integer.valueOf("12"));
 
 
-    assertEquals(beanType.getExpressionPath("billingAddress.country.code").pathGet(e0), "NZ");
-    assertEquals(beanType.getExpressionPath("billingAddress.country.name").pathGet(e0), "New Zealand");
+    assertEquals(beanType.expressionPath("billingAddress.country.code").pathGet(e0), "NZ");
+    assertEquals(beanType.expressionPath("billingAddress.country.name").pathGet(e0), "New Zealand");
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/el/TestUnderscoreParam.java b/ebean-test/src/test/java/org/tests/el/TestUnderscoreParam.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/el/TestUnderscoreParam.java
rename to ebean-test/src/test/java/org/tests/el/TestUnderscoreParam.java
index 2e82d1a83..2646707e6 100644
--- a/ebean-core/src/test/java/org/tests/el/TestUnderscoreParam.java
+++ b/ebean-test/src/test/java/org/tests/el/TestUnderscoreParam.java
@@ -1,19 +1,17 @@
 package org.tests.el;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
-import org.junit.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestUnderscoreParam extends BaseTestCase {
 
   @Test
   public void test() {
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .where().raw("name like ?", "Rob%")
       .query();
 
diff --git a/ebean-core/src/test/java/org/tests/embedded/TestEmbeddedEmpty.java b/ebean-test/src/test/java/org/tests/embedded/TestEmbeddedEmpty.java
similarity index 95%
rename from ebean-core/src/test/java/org/tests/embedded/TestEmbeddedEmpty.java
rename to ebean-test/src/test/java/org/tests/embedded/TestEmbeddedEmpty.java
index eda307b53..0ef60c906 100644
--- a/ebean-core/src/test/java/org/tests/embedded/TestEmbeddedEmpty.java
+++ b/ebean-test/src/test/java/org/tests/embedded/TestEmbeddedEmpty.java
@@ -1,7 +1,7 @@
 package org.tests.embedded;
 
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.embedded.EAddress;
 import org.tests.model.embedded.EAddressStatus;
 import org.tests.model.embedded.EPerson3;
diff --git a/ebean-core/src/test/java/org/tests/enhancement/TestConstructorManyAddAll.java b/ebean-test/src/test/java/org/tests/enhancement/TestConstructorManyAddAll.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/enhancement/TestConstructorManyAddAll.java
rename to ebean-test/src/test/java/org/tests/enhancement/TestConstructorManyAddAll.java
index e328b3b8c..1360c1cb6 100644
--- a/ebean-core/src/test/java/org/tests/enhancement/TestConstructorManyAddAll.java
+++ b/ebean-test/src/test/java/org/tests/enhancement/TestConstructorManyAddAll.java
@@ -1,9 +1,9 @@
 package org.tests.enhancement;
 
 import io.ebean.BaseTestCase;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MRole;
 import org.tests.model.basic.MUser;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/ebean-core/src/test/java/org/tests/enhancement/TestConstructorPutfieldReplacement.java b/ebean-test/src/test/java/org/tests/enhancement/TestConstructorPutfieldReplacement.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/enhancement/TestConstructorPutfieldReplacement.java
rename to ebean-test/src/test/java/org/tests/enhancement/TestConstructorPutfieldReplacement.java
index 4b148c02e..3a945c8e7 100644
--- a/ebean-core/src/test/java/org/tests/enhancement/TestConstructorPutfieldReplacement.java
+++ b/ebean-test/src/test/java/org/tests/enhancement/TestConstructorPutfieldReplacement.java
@@ -3,10 +3,11 @@ package org.tests.enhancement;
 import io.ebean.BaseTestCase;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.PFile;
 import org.tests.model.basic.PFileContent;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestConstructorPutfieldReplacement extends BaseTestCase {
 
@@ -21,9 +22,8 @@ public class TestConstructorPutfieldReplacement extends BaseTestCase {
     int namePos = ebi.findProperty("name");
     int fileContentPos = ebi.findProperty("fileContent");
 
-    Assert.assertTrue(ebi.isLoadedProperty(namePos));
-    Assert.assertTrue(ebi.isLoadedProperty(fileContentPos));
-
+    assertTrue(ebi.isLoadedProperty(namePos));
+    assertTrue(ebi.isLoadedProperty(fileContentPos));
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/enhancement/TestEnhancementEquals.java b/ebean-test/src/test/java/org/tests/enhancement/TestEnhancementEquals.java
similarity index 60%
rename from ebean-core/src/test/java/org/tests/enhancement/TestEnhancementEquals.java
rename to ebean-test/src/test/java/org/tests/enhancement/TestEnhancementEquals.java
index 10bd1b0d6..515d45e73 100644
--- a/ebean-core/src/test/java/org/tests/enhancement/TestEnhancementEquals.java
+++ b/ebean-test/src/test/java/org/tests/enhancement/TestEnhancementEquals.java
@@ -1,9 +1,10 @@
 package org.tests.enhancement;
 
 import io.ebean.BaseTestCase;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Product;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 /**
  * Note take care if you run this test in an IDE with a debugger as that can trigger the equals and
@@ -22,12 +23,12 @@ public class TestEnhancementEquals extends BaseTestCase {
     Product product2 = new Product();
     product2.setId(345);
 
-    Assert.assertEquals("equal based on id", product1, product2);
-    Assert.assertEquals("hashCode equal based on id", product1.hashCode(), product2.hashCode());
+    assertEquals(product1, product2);
+    assertEquals(product1.hashCode(), product2.hashCode());
 
     product2.setName("kumera");
-    Assert.assertEquals("still equal based on identity", product1, product2);
-    Assert.assertEquals("still hashCode equal based on id", product1.hashCode(), product2.hashCode());
+    assertEquals(product1, product2);
+    assertEquals(product1.hashCode(), product2.hashCode());
   }
 
 
@@ -42,13 +43,13 @@ public class TestEnhancementEquals extends BaseTestCase {
     product1.setId(345);
     int hashcode2 = product1.hashCode();
 
-    Assert.assertEquals("hashCode can't change", hashcode1, hashcode2);
+    assertEquals(hashcode1, hashcode2);
 
     Product product2 = new Product();
     product2.setId(345);
 
-    Assert.assertFalse("Not equal now", product1.equals(product2));
-    Assert.assertTrue("Different hashCode", product1.hashCode() != product2.hashCode());
+    assertNotEquals(product1, product2);
+    assertTrue(product1.hashCode() != product2.hashCode());
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/example/ModUuidGenerator.java b/ebean-test/src/test/java/org/tests/example/ModUuidGenerator.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/example/ModUuidGenerator.java
rename to ebean-test/src/test/java/org/tests/example/ModUuidGenerator.java
diff --git a/ebean-core/src/test/java/org/tests/expression/bitwise/BwBean.java b/ebean-test/src/test/java/org/tests/expression/bitwise/BwBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/expression/bitwise/BwBean.java
rename to ebean-test/src/test/java/org/tests/expression/bitwise/BwBean.java
diff --git a/ebean-core/src/test/java/org/tests/expression/bitwise/BwFlags.java b/ebean-test/src/test/java/org/tests/expression/bitwise/BwFlags.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/expression/bitwise/BwFlags.java
rename to ebean-test/src/test/java/org/tests/expression/bitwise/BwFlags.java
diff --git a/ebean-core/src/test/java/org/tests/expression/bitwise/TestBitwiseExpressions.java b/ebean-test/src/test/java/org/tests/expression/bitwise/TestBitwiseExpressions.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/expression/bitwise/TestBitwiseExpressions.java
rename to ebean-test/src/test/java/org/tests/expression/bitwise/TestBitwiseExpressions.java
index 013060804..30cdafd84 100644
--- a/ebean-core/src/test/java/org/tests/expression/bitwise/TestBitwiseExpressions.java
+++ b/ebean-test/src/test/java/org/tests/expression/bitwise/TestBitwiseExpressions.java
@@ -1,8 +1,8 @@
 package org.tests.expression.bitwise;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -22,7 +22,7 @@ public class TestBitwiseExpressions extends BaseTestCase {
 
   private void bitwiseNot() {
 
-    List<BwBean> notColour = Ebean.find(BwBean.class)
+    List<BwBean> notColour = DB.find(BwBean.class)
       // HAS_COLOUR not set ...
       .where().bitwiseNot("flags", BwFlags.HAS_COLOUR)
       .findList();
@@ -34,7 +34,7 @@ public class TestBitwiseExpressions extends BaseTestCase {
 
   private void bitwiseAnd() {
 
-    List<BwBean> list = Ebean.find(BwBean.class)
+    List<BwBean> list = DB.find(BwBean.class)
       // not bulk set AND size set
       .where().bitwiseAnd("flags", BwFlags.HAS_BULK + BwFlags.HAS_SIZE, BwFlags.HAS_SIZE)
       .findList();
@@ -42,7 +42,7 @@ public class TestBitwiseExpressions extends BaseTestCase {
     assertThat(list).hasSize(1);
     assertThat(list.get(0).getName()).isEqualTo("SizeOnly");
 
-    list = Ebean.find(BwBean.class)
+    list = DB.find(BwBean.class)
       // bulk set AND not size set
       .where().bitwiseAnd("flags", BwFlags.HAS_BULK + BwFlags.HAS_SIZE, BwFlags.HAS_BULK)
       .findList();
@@ -50,7 +50,7 @@ public class TestBitwiseExpressions extends BaseTestCase {
     assertThat(list).hasSize(1);
     assertThat(list.get(0).getName()).isEqualTo("ColourAndBulk");
 
-    list = Ebean.find(BwBean.class)
+    list = DB.find(BwBean.class)
       // bulk set AND not size set
       .where().bitwiseAnd("flags", BwFlags.HAS_BULK + BwFlags.HAS_COLOUR, BwFlags.HAS_COLOUR)
       .findList();
@@ -61,7 +61,7 @@ public class TestBitwiseExpressions extends BaseTestCase {
 
   private void bitwiseAny() {
 
-    List<BwBean> list = Ebean.find(BwBean.class)
+    List<BwBean> list = DB.find(BwBean.class)
       .where().bitwiseAny("flags", BwFlags.HAS_BULK + BwFlags.HAS_SIZE)
       .findList();
 
@@ -71,19 +71,19 @@ public class TestBitwiseExpressions extends BaseTestCase {
     assertThat(list.get(2).getName()).isEqualTo("Everything");
 
 
-    list = Ebean.find(BwBean.class)
+    list = DB.find(BwBean.class)
       .where().bitwiseAny("flags", BwFlags.HAS_BULK + BwFlags.HAS_SIZE + BwFlags.HAS_COLOUR)
       .findList();
 
     assertThat(list).hasSize(4);
 
-    list = Ebean.find(BwBean.class)
+    list = DB.find(BwBean.class)
       .where().bitwiseAny("flags", BwFlags.HAS_SIZE + BwFlags.HAS_COLOUR)
       .findList();
 
     assertThat(list).hasSize(4);
 
-    list = Ebean.find(BwBean.class)
+    list = DB.find(BwBean.class)
       .where().bitwiseAny("flags", BwFlags.HAS_SIZE)
       .findList();
 
@@ -91,7 +91,7 @@ public class TestBitwiseExpressions extends BaseTestCase {
     assertThat(list.get(0).getName()).isEqualTo("SizeOnly");
     assertThat(list.get(1).getName()).isEqualTo("Everything");
 
-    list = Ebean.find(BwBean.class)
+    list = DB.find(BwBean.class)
       .where().bitwiseAny("flags", BwFlags.HAS_COLOUR)
       .findList();
 
@@ -103,14 +103,14 @@ public class TestBitwiseExpressions extends BaseTestCase {
 
   private void bitwiseAll() {
 
-    List<BwBean> list = Ebean.find(BwBean.class)
+    List<BwBean> list = DB.find(BwBean.class)
       .where().bitwiseAll("flags", BwFlags.HAS_BULK + BwFlags.HAS_SIZE)
       .findList();
 
     assertThat(list).hasSize(1);
     assertThat(list.get(0).getName()).isEqualTo("Everything");
 
-    list = Ebean.find(BwBean.class)
+    list = DB.find(BwBean.class)
       .where().bitwiseAll("flags", BwFlags.HAS_BULK + BwFlags.HAS_COLOUR)
       .order().asc("id")
       .findList();
@@ -119,7 +119,7 @@ public class TestBitwiseExpressions extends BaseTestCase {
     assertThat(list.get(0).getName()).isEqualTo("ColourAndBulk");
     assertThat(list.get(1).getName()).isEqualTo("Everything");
 
-    list = Ebean.find(BwBean.class)
+    list = DB.find(BwBean.class)
       .where().bitwiseAll("flags", BwFlags.HAS_SIZE)
       .order().asc("id")
       .findList();
@@ -128,7 +128,7 @@ public class TestBitwiseExpressions extends BaseTestCase {
     assertThat(list.get(0).getName()).isEqualTo("SizeOnly");
     assertThat(list.get(1).getName()).isEqualTo("Everything");
 
-    list = Ebean.find(BwBean.class)
+    list = DB.find(BwBean.class)
       .where().bitwiseAll("flags", BwFlags.HAS_COLOUR)
       .order().asc("id")
       .findList();
@@ -142,7 +142,7 @@ public class TestBitwiseExpressions extends BaseTestCase {
 
   private void setup() {
 
-    Ebean.find(BwBean.class).delete();
+    DB.find(BwBean.class).delete();
 
     new BwBean("Nothing", BwFlags.NOTHING).save();
     new BwBean("ColourOnly", BwFlags.HAS_COLOUR).save();
diff --git a/ebean-core/src/test/java/org/tests/family/TestInheritance.java b/ebean-test/src/test/java/org/tests/family/TestInheritance.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/family/TestInheritance.java
rename to ebean-test/src/test/java/org/tests/family/TestInheritance.java
index a24127737..485428b79 100644
--- a/ebean-core/src/test/java/org/tests/family/TestInheritance.java
+++ b/ebean-test/src/test/java/org/tests/family/TestInheritance.java
@@ -1,22 +1,19 @@
 package org.tests.family;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanProperty;
 import io.ebeaninternal.server.deploy.BeanPropertyAssocOne;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
 import org.tests.model.family.ChildPerson;
 import org.tests.model.family.GrandParentPerson;
 import org.tests.model.family.ParentPerson;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 
 public class TestInheritance extends BaseTestCase {
@@ -24,9 +21,9 @@ public class TestInheritance extends BaseTestCase {
 
   @Test
   public void testDescriptor() {
-    BeanDescriptor<GrandParentPerson> desc = spiEbeanServer().getBeanDescriptor(GrandParentPerson.class);
-    BeanProperty prop1 = desc.getBeanProperty("someBean");
-    BeanProperty prop2 = desc.getBeanProperty("effectiveBean");
+    BeanDescriptor<GrandParentPerson> desc = spiEbeanServer().descriptor(GrandParentPerson.class);
+    BeanProperty prop1 = desc.beanProperty("someBean");
+    BeanProperty prop2 = desc.beanProperty("effectiveBean");
 
     assertEquals(BeanPropertyAssocOne.class, prop1.getClass());
     assertEquals(BeanPropertyAssocOne.class, prop2.getClass());
@@ -220,9 +217,9 @@ public class TestInheritance extends BaseTestCase {
     assertEquals("Munich", grandparent1.getAddress());
     assertEquals(1, grandparent1.getEffectiveBean().getId().intValue());
 
-    Ebean.find(ChildPerson.class).delete();
-    Ebean.find(GrandParentPerson.class).delete();
-    Ebean.find(EBasic.class).delete();
+    DB.find(ChildPerson.class).delete();
+    DB.find(GrandParentPerson.class).delete();
+    DB.find(EBasic.class).delete();
   }
 
   @Test
@@ -265,8 +262,8 @@ public class TestInheritance extends BaseTestCase {
     count = server().find(GrandParentPerson.class).where().eq("basicSameName.description", "Description A").findCount();
     assertEquals(1, count);
 
-    Ebean.find(ChildPerson.class).delete();
-    Ebean.find(GrandParentPerson.class).delete();
-    Ebean.find(EBasic.class).delete();
+    DB.find(ChildPerson.class).delete();
+    DB.find(GrandParentPerson.class).delete();
+    DB.find(EBasic.class).delete();
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/generated/TestGeneratedProperties.java b/ebean-test/src/test/java/org/tests/generated/TestGeneratedProperties.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/generated/TestGeneratedProperties.java
rename to ebean-test/src/test/java/org/tests/generated/TestGeneratedProperties.java
index da9aa3ceb..c44fea1fa 100644
--- a/ebean-core/src/test/java/org/tests/generated/TestGeneratedProperties.java
+++ b/ebean-test/src/test/java/org/tests/generated/TestGeneratedProperties.java
@@ -1,12 +1,12 @@
 package org.tests.generated;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.EGenProps;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestGeneratedProperties extends BaseTestCase {
 
@@ -15,7 +15,7 @@ public class TestGeneratedProperties extends BaseTestCase {
 
     EGenProps bean = new EGenProps();
     bean.setName("inserting");
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertNotNull(bean.getId());
     assertNotNull(bean.getVersion());
@@ -38,13 +38,13 @@ public class TestGeneratedProperties extends BaseTestCase {
     assertThat(bean.getWhenModified().toInstant().toEpochMilli()).isEqualTo(bean.getLongCreated());
 
     bean.setName("updating...");
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertThat(bean.getWhenModified()).isNotEqualTo(bean.getLongCreated());
     assertThat(bean.getWhenModified().toInstant().toEpochMilli()).isEqualTo(bean.getLongUpdated());
     assertThat(bean.getInstantUpdated().toEpochMilli()).isEqualTo(bean.getLongUpdated());
     assertThat(bean.getInstantCreated().toEpochMilli()).isEqualTo(bean.getLongCreated());
 
-    Ebean.delete(bean);
+    DB.delete(bean);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/generated/TestGeneratedWho.java b/ebean-test/src/test/java/org/tests/generated/TestGeneratedWho.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/generated/TestGeneratedWho.java
rename to ebean-test/src/test/java/org/tests/generated/TestGeneratedWho.java
index 9adb3bb5a..00c3b03cb 100644
--- a/ebean-core/src/test/java/org/tests/generated/TestGeneratedWho.java
+++ b/ebean-test/src/test/java/org/tests/generated/TestGeneratedWho.java
@@ -1,16 +1,14 @@
 package org.tests.generated;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.MyCurrentUserProvider;
+import org.junit.jupiter.api.Test;
 import org.tests.model.EWhoProps;
-import org.junit.Test;
 import org.tests.model.generated.User;
 import org.tests.model.generated.WhoPropsOneToMany;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestGeneratedWho extends BaseTestCase {
 
@@ -21,7 +19,7 @@ public class TestGeneratedWho extends BaseTestCase {
     bean.setName("one");
 
     MyCurrentUserProvider.setUser("INSERT_WHO_1");
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertEquals("one", bean.getName());
     assertEquals("INSERT_WHO_1", bean.getWhoCreated());
@@ -31,7 +29,7 @@ public class TestGeneratedWho extends BaseTestCase {
 
     MyCurrentUserProvider.setUser("UPDATE_WHO_1");
     bean.setName("two");
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertEquals("two", bean.getName());
     assertEquals("INSERT_WHO_1", bean.getWhoCreated());
@@ -39,7 +37,7 @@ public class TestGeneratedWho extends BaseTestCase {
 
     MyCurrentUserProvider.setUser("UPDATE_WHO_2");
     bean.setName("three");
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertEquals("INSERT_WHO_1", bean.getWhoCreated());
     assertEquals("UPDATE_WHO_2", bean.getWhoModified());
@@ -52,15 +50,15 @@ public class TestGeneratedWho extends BaseTestCase {
     User creator = new User("jack");
     User maintainer01 = new User("jill");
     User maintainer02 = new User("joe");
-    Ebean.save(creator);
-    Ebean.save(maintainer01);
-    Ebean.save(maintainer02);
+    DB.save(creator);
+    DB.save(maintainer01);
+    DB.save(maintainer02);
 
     WhoPropsOneToMany bean = new WhoPropsOneToMany();
     bean.setName("one");
 
     MyCurrentUserProvider.setUser(creator);
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertNotNull(bean.getWhoCreated());
     assertEquals(creator.getId(), bean.getWhoCreated().getId());
@@ -68,7 +66,7 @@ public class TestGeneratedWho extends BaseTestCase {
 
     MyCurrentUserProvider.setUser(maintainer01);
     bean.setName("two");
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertEquals("two", bean.getName());
     assertEquals(creator.getId(), bean.getWhoCreated().getId());
@@ -76,7 +74,7 @@ public class TestGeneratedWho extends BaseTestCase {
 
     MyCurrentUserProvider.setUser(maintainer02);
     bean.setName("three");
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertEquals(creator.getId(), bean.getWhoCreated().getId());
     assertEquals(maintainer02.getId(), bean.getWhoModified().getId());
@@ -87,7 +85,7 @@ public class TestGeneratedWho extends BaseTestCase {
   @Test
   public void insertNullIntoOneToManyWhoCreated() {
     User creator = new User("jack");
-    Ebean.save(creator);
+    DB.save(creator);
 
     WhoPropsOneToMany bean = new WhoPropsOneToMany();
     bean.setName("one");
@@ -95,7 +93,7 @@ public class TestGeneratedWho extends BaseTestCase {
     bean.setWhoModified(creator);
 
     MyCurrentUserProvider.setUser(null);
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertNull(bean.getWhoCreated());
     assertNull(bean.getWhoModified());
diff --git a/ebean-core/src/test/java/org/tests/genkey/TestGeneratedKeys.java b/ebean-test/src/test/java/org/tests/genkey/TestGeneratedKeys.java
similarity index 51%
rename from ebean-core/src/test/java/org/tests/genkey/TestGeneratedKeys.java
rename to ebean-test/src/test/java/org/tests/genkey/TestGeneratedKeys.java
index 78af8f844..a663738c8 100644
--- a/ebean-core/src/test/java/org/tests/genkey/TestGeneratedKeys.java
+++ b/ebean-test/src/test/java/org/tests/genkey/TestGeneratedKeys.java
@@ -1,13 +1,14 @@
 package org.tests.genkey;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TOne;
-import junit.framework.TestCase;
-import org.junit.Assert;
 
-public class TestGeneratedKeys extends TestCase {
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
+public class TestGeneratedKeys {
 
+  @Test
   public void testJdbcBatchInsert() {
 
     TOne c = new TOne();
@@ -18,19 +19,18 @@ public class TestGeneratedKeys extends TestCase {
     c1.setName("Two");
     c1.setDescription("Test Gen Key Two");
 
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
-      Ebean.save(c);
-      Ebean.save(c1);
+      DB.save(c);
+      DB.save(c1);
     } finally {
-      Ebean.commitTransaction();
+      DB.commitTransaction();
     }
     Integer id = c.getId();
-    Assert.assertNotNull("Get Id back after insert", id);
+    assertNotNull(id);
 
     Integer id1 = c1.getId();
-    Assert.assertNotNull("Get Id back after insert", id1);
-
+    assertNotNull(id1);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/genkey/TestSeqBatch.java b/ebean-test/src/test/java/org/tests/genkey/TestSeqBatch.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/genkey/TestSeqBatch.java
rename to ebean-test/src/test/java/org/tests/genkey/TestSeqBatch.java
index 24b0b787d..5f2b96fb3 100644
--- a/ebean-core/src/test/java/org/tests/genkey/TestSeqBatch.java
+++ b/ebean-test/src/test/java/org/tests/genkey/TestSeqBatch.java
@@ -3,9 +3,10 @@ package org.tests.genkey;
 import io.ebean.BaseTestCase;
 import io.ebean.config.dbplatform.IdType;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TOne;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestSeqBatch extends BaseTestCase {
 
@@ -15,16 +16,12 @@ public class TestSeqBatch extends BaseTestCase {
       return;
     }
 
-    BeanDescriptor<TOne> d = spiEbeanServer().getBeanDescriptor(TOne.class);
-
+    BeanDescriptor<TOne> d = spiEbeanServer().descriptor(TOne.class);
     Object id = d.nextId(null);
-    Assert.assertNotNull(id);
-    // System.out.println(id);
-
+    assertNotNull(id);
     for (int i = 0; i < 16; i++) {
       Object id2 = d.nextId(null);
-      Assert.assertNotNull(id2);
-      // System.out.println(id2);
+      assertNotNull(id2);
     }
   }
 
diff --git a/ebean-core/src/test/java/org/tests/history/TestHistoryInsert.java b/ebean-test/src/test/java/org/tests/history/TestHistoryInsert.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/history/TestHistoryInsert.java
rename to ebean-test/src/test/java/org/tests/history/TestHistoryInsert.java
index 61db881a1..c78e49c6e 100644
--- a/ebean-core/src/test/java/org/tests/history/TestHistoryInsert.java
+++ b/ebean-test/src/test/java/org/tests/history/TestHistoryInsert.java
@@ -1,15 +1,10 @@
 package org.tests.history;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.SqlQuery;
-import io.ebean.SqlRow;
-import io.ebean.Transaction;
-import io.ebean.Version;
+import io.ebean.*;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import io.ebeantest.LoggedSql;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.converstation.User;
diff --git a/ebean-core/src/test/java/org/tests/idkeys/TestCustomId.java b/ebean-test/src/test/java/org/tests/idkeys/TestCustomId.java
similarity index 65%
rename from ebean-core/src/test/java/org/tests/idkeys/TestCustomId.java
rename to ebean-test/src/test/java/org/tests/idkeys/TestCustomId.java
index 6f94dbd53..4ad721274 100644
--- a/ebean-core/src/test/java/org/tests/idkeys/TestCustomId.java
+++ b/ebean-test/src/test/java/org/tests/idkeys/TestCustomId.java
@@ -2,12 +2,12 @@ package org.tests.idkeys;
 
 import io.avaje.moduuid.ModUUID;
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.ECustomId;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestCustomId extends BaseTestCase {
 
@@ -15,7 +15,7 @@ public class TestCustomId extends BaseTestCase {
   public void insert() {
 
     ECustomId bean = new ECustomId("fred");
-    Ebean.save(bean);
+    DB.save(bean);
     assertNotNull(bean.getId());
   }
 
@@ -25,9 +25,9 @@ public class TestCustomId extends BaseTestCase {
     ECustomId bean = new ECustomId("gotId");
     String explicitId = ModUUID.newShortId();
     bean.setId(explicitId);
-    Ebean.save(bean);
+    DB.save(bean);
 
-    ECustomId found = Ebean.find(ECustomId.class, explicitId);
+    ECustomId found = DB.find(ECustomId.class, explicitId);
     assertEquals(found.getName(), bean.getName());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/idkeys/TestGeneratedKeys.java b/ebean-test/src/test/java/org/tests/idkeys/TestGeneratedKeys.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/idkeys/TestGeneratedKeys.java
rename to ebean-test/src/test/java/org/tests/idkeys/TestGeneratedKeys.java
index ee46be72f..537c2fe4b 100644
--- a/ebean-core/src/test/java/org/tests/idkeys/TestGeneratedKeys.java
+++ b/ebean-test/src/test/java/org/tests/idkeys/TestGeneratedKeys.java
@@ -6,7 +6,7 @@ import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.config.dbplatform.IdType;
 import io.ebeaninternal.api.SpiEbeanServer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.idkeys.db.GenKeyIdentity;
 import org.tests.idkeys.db.GenKeySequence;
 
@@ -14,9 +14,7 @@ import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestGeneratedKeys extends BaseTestCase {
 
@@ -51,7 +49,7 @@ public class TestGeneratedKeys extends BaseTestCase {
   private long readSequenceValue(Transaction tx, String sequence) throws SQLException {
     Statement stm = null;
     try {
-      stm = tx.getConnection().createStatement();
+      stm = tx.connection().createStatement();
       ResultSet rs = stm.executeQuery("select currval('" + sequence + "')");
       rs.next();
 
diff --git a/ebean-core/src/test/java/org/tests/idkeys/TestLazyLoad.java b/ebean-test/src/test/java/org/tests/idkeys/TestLazyLoad.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/idkeys/TestLazyLoad.java
rename to ebean-test/src/test/java/org/tests/idkeys/TestLazyLoad.java
index 1ea628a36..e6b2fbad8 100644
--- a/ebean-core/src/test/java/org/tests/idkeys/TestLazyLoad.java
+++ b/ebean-test/src/test/java/org/tests/idkeys/TestLazyLoad.java
@@ -1,15 +1,15 @@
 package org.tests.idkeys;
 
-import org.junit.Test;
-import org.tests.model.basic.TOne;
-
 import io.ebean.BaseTestCase;
-
-import static org.junit.Assert.*;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.TOne;
 
 import java.sql.SQLException;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 /**
  * Test lazy loading
  */
diff --git a/ebean-core/src/test/java/org/tests/idkeys/TestSimpleIdInsert.java b/ebean-test/src/test/java/org/tests/idkeys/TestSimpleIdInsert.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/idkeys/TestSimpleIdInsert.java
rename to ebean-test/src/test/java/org/tests/idkeys/TestSimpleIdInsert.java
index 25d72bae2..6627cd81f 100644
--- a/ebean-core/src/test/java/org/tests/idkeys/TestSimpleIdInsert.java
+++ b/ebean-test/src/test/java/org/tests/idkeys/TestSimpleIdInsert.java
@@ -1,22 +1,22 @@
 package org.tests.idkeys;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.ESimple;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestSimpleIdInsert extends BaseTestCase {
 
   @Test
   public void test() {
-
     ESimple e = new ESimple();
     e.setName("name");
 
-    Ebean.save(e);
+    DB.save(e);
 
-    Assert.assertNotNull(e.getId());
+    assertNotNull(e.getId());
 
   }
 
@@ -27,24 +27,24 @@ public class TestSimpleIdInsert extends BaseTestCase {
 //		GlobalProperties.put("datasource.default", "hsqldb");
 //		GlobalProperties.put("ebean.classes", ESimple.class.getName());
 //
-//		Transaction transaction = Ebean.beginTransaction();
+//		Transaction transaction = DB.beginTransaction();
 //		try {
 //			transaction.setBatchMode(true);
 //			transaction.setLogLevel(LogLevel.SQL);
 //			ESimple e = new ESimple();
 //			e.setName("name");
-//			Ebean.save(e);
+//			DB.save(e);
 //
 //			ESimple e2 = new ESimple();
 //			e2.setName("name2");
-//			Ebean.save(e2);
+//			DB.save(e2);
 //			transaction.commit();
 //
 //			Assert.assertNotNull(e.getId());
 //			Assert.assertNotNull(e2.getId());
 //
 //		} finally {
-//			Ebean.endTransaction();
+//			DB.endTransaction();
 //		}
 //	}
 
diff --git a/ebean-core/src/test/java/org/tests/idkeys/db/AuditLog.java b/ebean-test/src/test/java/org/tests/idkeys/db/AuditLog.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/idkeys/db/AuditLog.java
rename to ebean-test/src/test/java/org/tests/idkeys/db/AuditLog.java
diff --git a/ebean-core/src/test/java/org/tests/idkeys/db/GenKeyIdentity.java b/ebean-test/src/test/java/org/tests/idkeys/db/GenKeyIdentity.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/idkeys/db/GenKeyIdentity.java
rename to ebean-test/src/test/java/org/tests/idkeys/db/GenKeyIdentity.java
diff --git a/ebean-core/src/test/java/org/tests/idkeys/db/GenKeySequence.java b/ebean-test/src/test/java/org/tests/idkeys/db/GenKeySequence.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/idkeys/db/GenKeySequence.java
rename to ebean-test/src/test/java/org/tests/idkeys/db/GenKeySequence.java
diff --git a/ebean-core/src/test/java/org/tests/inherit/ChildA.java b/ebean-test/src/test/java/org/tests/inherit/ChildA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inherit/ChildA.java
rename to ebean-test/src/test/java/org/tests/inherit/ChildA.java
diff --git a/ebean-core/src/test/java/org/tests/inherit/ChildB.java b/ebean-test/src/test/java/org/tests/inherit/ChildB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inherit/ChildB.java
rename to ebean-test/src/test/java/org/tests/inherit/ChildB.java
diff --git a/ebean-core/src/test/java/org/tests/inherit/DIntChild1.java b/ebean-test/src/test/java/org/tests/inherit/DIntChild1.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inherit/DIntChild1.java
rename to ebean-test/src/test/java/org/tests/inherit/DIntChild1.java
diff --git a/ebean-core/src/test/java/org/tests/inherit/DIntChild2.java b/ebean-test/src/test/java/org/tests/inherit/DIntChild2.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inherit/DIntChild2.java
rename to ebean-test/src/test/java/org/tests/inherit/DIntChild2.java
diff --git a/ebean-core/src/test/java/org/tests/inherit/DIntChildBase.java b/ebean-test/src/test/java/org/tests/inherit/DIntChildBase.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inherit/DIntChildBase.java
rename to ebean-test/src/test/java/org/tests/inherit/DIntChildBase.java
diff --git a/ebean-core/src/test/java/org/tests/inherit/DIntParent.java b/ebean-test/src/test/java/org/tests/inherit/DIntParent.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/inherit/DIntParent.java
rename to ebean-test/src/test/java/org/tests/inherit/DIntParent.java
index 1b491a9bd..f67cd5041 100644
--- a/ebean-core/src/test/java/org/tests/inherit/DIntParent.java
+++ b/ebean-test/src/test/java/org/tests/inherit/DIntParent.java
@@ -1,12 +1,6 @@
 package org.tests.inherit;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "dint_parent")
diff --git a/ebean-core/src/test/java/org/tests/inherit/Data.java b/ebean-test/src/test/java/org/tests/inherit/Data.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/inherit/Data.java
rename to ebean-test/src/test/java/org/tests/inherit/Data.java
index 616beefec..0f20e16c3 100644
--- a/ebean-core/src/test/java/org/tests/inherit/Data.java
+++ b/ebean-test/src/test/java/org/tests/inherit/Data.java
@@ -1,10 +1,6 @@
 package org.tests.inherit;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/inherit/EUncle.java b/ebean-test/src/test/java/org/tests/inherit/EUncle.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/inherit/EUncle.java
rename to ebean-test/src/test/java/org/tests/inherit/EUncle.java
index f9c8960f7..6dbe92089 100644
--- a/ebean-core/src/test/java/org/tests/inherit/EUncle.java
+++ b/ebean-test/src/test/java/org/tests/inherit/EUncle.java
@@ -1,10 +1,6 @@
 package org.tests.inherit;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "rawinherit_uncle")
diff --git a/ebean-core/src/test/java/org/tests/inherit/InheritDiscIntTest.java b/ebean-test/src/test/java/org/tests/inherit/InheritDiscIntTest.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/inherit/InheritDiscIntTest.java
rename to ebean-test/src/test/java/org/tests/inherit/InheritDiscIntTest.java
index 3b892b864..14712485e 100644
--- a/ebean-core/src/test/java/org/tests/inherit/InheritDiscIntTest.java
+++ b/ebean-test/src/test/java/org/tests/inherit/InheritDiscIntTest.java
@@ -1,10 +1,10 @@
 package org.tests.inherit;
 
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class InheritDiscIntTest {
 
diff --git a/ebean-core/src/test/java/org/tests/inherit/Parent.java b/ebean-test/src/test/java/org/tests/inherit/Parent.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/inherit/Parent.java
rename to ebean-test/src/test/java/org/tests/inherit/Parent.java
index ff1dfb140..4eac1553a 100644
--- a/ebean-core/src/test/java/org/tests/inherit/Parent.java
+++ b/ebean-test/src/test/java/org/tests/inherit/Parent.java
@@ -1,13 +1,6 @@
 package org.tests.inherit;
 
-import javax.persistence.CascadeType;
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.ManyToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/inherit/ParentAggregate.java b/ebean-test/src/test/java/org/tests/inherit/ParentAggregate.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inherit/ParentAggregate.java
rename to ebean-test/src/test/java/org/tests/inherit/ParentAggregate.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/InnerReport.java b/ebean-test/src/test/java/org/tests/inheritance/InnerReport.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/inheritance/InnerReport.java
rename to ebean-test/src/test/java/org/tests/inheritance/InnerReport.java
index 2a8449c8e..8a3964f9e 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/InnerReport.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/InnerReport.java
@@ -1,10 +1,6 @@
 package org.tests.inheritance;
 
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToOne;
+import javax.persistence.*;
 
 /**
  */
diff --git a/ebean-core/src/test/java/org/tests/inheritance/OrganizationNode.java b/ebean-test/src/test/java/org/tests/inheritance/OrganizationNode.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/inheritance/OrganizationNode.java
rename to ebean-test/src/test/java/org/tests/inheritance/OrganizationNode.java
index 3582a7b7d..613637800 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/OrganizationNode.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/OrganizationNode.java
@@ -1,16 +1,10 @@
 package org.tests.inheritance;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.MappedSuperclass;
-import javax.persistence.OneToOne;
-import javax.validation.constraints.NotNull;
-
 import io.ebean.annotation.Index;
 
+import javax.persistence.*;
+import javax.validation.constraints.NotNull;
+
 /**
  * Model class to reference an organization node.
  *
diff --git a/ebean-core/src/test/java/org/tests/inheritance/OrganizationTreeNode.java b/ebean-test/src/test/java/org/tests/inheritance/OrganizationTreeNode.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/OrganizationTreeNode.java
rename to ebean-test/src/test/java/org/tests/inheritance/OrganizationTreeNode.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/OrganizationUnit.java b/ebean-test/src/test/java/org/tests/inheritance/OrganizationUnit.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/OrganizationUnit.java
rename to ebean-test/src/test/java/org/tests/inheritance/OrganizationUnit.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/Stockforecast.java b/ebean-test/src/test/java/org/tests/inheritance/Stockforecast.java
similarity index 59%
rename from ebean-core/src/test/java/org/tests/inheritance/Stockforecast.java
rename to ebean-test/src/test/java/org/tests/inheritance/Stockforecast.java
index 4ae802112..c5ac10b64 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/Stockforecast.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/Stockforecast.java
@@ -1,11 +1,6 @@
 package org.tests.inheritance;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
+import javax.persistence.*;
 
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestDuplicateKeyException.java b/ebean-test/src/test/java/org/tests/inheritance/TestDuplicateKeyException.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/inheritance/TestDuplicateKeyException.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestDuplicateKeyException.java
index 2b53a3d4a..5a5036721 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestDuplicateKeyException.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestDuplicateKeyException.java
@@ -2,13 +2,14 @@ package org.tests.inheritance;
 
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.AttributeHolder;
 import org.tests.model.basic.ListAttribute;
 import org.tests.model.basic.ListAttributeValue;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestDuplicateKeyException extends BaseTestCase {
 
   /**
@@ -23,28 +24,28 @@ public class TestDuplicateKeyException extends BaseTestCase {
     // Setup the data first
     final ListAttributeValue value1 = new ListAttributeValue();
 
-    Ebean.save(value1);
+    DB.save(value1);
 
     final ListAttribute listAttribute = new ListAttribute();
     listAttribute.add(value1);
-    Ebean.save(listAttribute);
+    DB.save(listAttribute);
 
 
     final AttributeHolder holder = new AttributeHolder();
     holder.add(listAttribute);
 
     try {
-      Ebean.execute(() -> {
-        //Ebean.currentTransaction().log("-- saving holder first time");
+      DB.execute(() -> {
+        //DB.currentTransaction().log("-- saving holder first time");
         // Alternatively turn off cascade Persist for this transaction
-        //Ebean.currentTransaction().setPersistCascade(false);
-        Ebean.save(holder);
-//Ebean.currentTransaction().log("-- saving holder second time");
+        //DB.currentTransaction().setPersistCascade(false);
+        DB.save(holder);
+//DB.currentTransaction().log("-- saving holder second time");
         // we don't get this far before failing
-        //Ebean.save(holder);
+        //DB.save(holder);
       });
     } catch (Exception e) {
-      Assert.assertEquals(e.getMessage(), "test rollback");
+      assertEquals(e.getMessage(), "test rollback");
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestInheritInsert.java b/ebean-test/src/test/java/org/tests/inheritance/TestInheritInsert.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/inheritance/TestInheritInsert.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestInheritInsert.java
index 9376a400f..6dbe29216 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestInheritInsert.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestInheritInsert.java
@@ -1,20 +1,14 @@
 package org.tests.inheritance;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.tests.model.basic.Car;
-import org.tests.model.basic.CarAccessory;
-import org.tests.model.basic.CarFuse;
-import org.tests.model.basic.Truck;
-import org.tests.model.basic.Vehicle;
-import org.tests.model.basic.VehicleDriver;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestInheritInsert extends BaseTestCase {
 
@@ -23,35 +17,35 @@ public class TestInheritInsert extends BaseTestCase {
 
     Truck t = new Truck();
     t.setCapacity(10d);
-    Ebean.save(t);
+    DB.save(t);
 
-    Vehicle v = Ebean.find(Vehicle.class, t.getId());
+    Vehicle v = DB.find(Vehicle.class, t.getId());
     if (v instanceof Truck) {
       Truck t0 = (Truck) v;
       assertEquals(Double.valueOf(10d), t0.getCapacity());
       assertEquals(Double.valueOf(10d), ((Truck) v).getCapacity());
       assertNotNull(t0.getId());
     } else {
-      assertTrue("v not a Truck?", false);
+      fail();
     }
 
     VehicleDriver driver = new VehicleDriver();
     driver.setName("Jim");
     driver.setVehicle(v);
 
-    Ebean.save(driver);
+    DB.save(driver);
 
-    VehicleDriver d1 = Ebean.find(VehicleDriver.class, driver.getId());
+    VehicleDriver d1 = DB.find(VehicleDriver.class, driver.getId());
     v = d1.getVehicle();
     if (v instanceof Truck) {
       Double capacity = ((Truck) v).getCapacity();
       assertEquals(Double.valueOf(10d), capacity);
       assertNotNull(v.getId());
     } else {
-      assertTrue("v not a Truck?", false);
+      fail("v not a Truck?");
     }
 
-    List<VehicleDriver> list = Ebean.find(VehicleDriver.class).findList();
+    List<VehicleDriver> list = DB.find(VehicleDriver.class).findList();
     for (VehicleDriver vehicleDriver : list) {
       if (vehicleDriver.getVehicle() instanceof Truck) {
         Double capacity = ((Truck) vehicleDriver.getVehicle()).getCapacity();
@@ -65,14 +59,14 @@ public class TestInheritInsert extends BaseTestCase {
 
     Car car = new Car();
     car.setLicenseNumber("MARIOS_CAR_LICENSE");
-    Ebean.save(car);
+    DB.save(car);
 
     VehicleDriver driver = new VehicleDriver();
     driver.setName("Mario");
     driver.setVehicle(car);
-    Ebean.save(driver);
+    DB.save(driver);
 
-    Query<VehicleDriver> query = Ebean.find(VehicleDriver.class);
+    Query<VehicleDriver> query = DB.find(VehicleDriver.class);
     query.where().eq("vehicle.licenseNumber", "MARIOS_CAR_LICENSE");
     List<VehicleDriver> drivers = query.findList();
 
@@ -83,10 +77,10 @@ public class TestInheritInsert extends BaseTestCase {
     assertEquals("Mario", drivers.get(0).getName());
     assertEquals("MARIOS_CAR_LICENSE", drivers.get(0).getVehicle().getLicenseNumber());
 
-    Vehicle car2 = Ebean.find(Vehicle.class, car.getId());
+    Vehicle car2 = DB.find(Vehicle.class, car.getId());
 
     car2.setLicenseNumber("test");
-    Ebean.save(car);
+    DB.save(car);
 
   }
 
@@ -95,17 +89,17 @@ public class TestInheritInsert extends BaseTestCase {
 
     Car car = new Car();
     car.setLicenseNumber("ABC");
-    Ebean.save(car);
+    DB.save(car);
 
     CarFuse fuse = new CarFuse();
     fuse.setLocationCode("xdfg");
-    Ebean.save(fuse);
+    DB.save(fuse);
 
     CarAccessory accessory = new CarAccessory(car, fuse);
-    Ebean.save(accessory);
+    DB.save(accessory);
 
 
-    Query<Car> query = Ebean.find(Car.class)
+    Query<Car> query = DB.find(Car.class)
       .fetch("accessories")
       .where()
       .eq("id", car.getId())
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceBatchLazyLoad.java b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceBatchLazyLoad.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/inheritance/TestInheritanceBatchLazyLoad.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestInheritanceBatchLazyLoad.java
index df91ad2de..0f72ec0e6 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceBatchLazyLoad.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceBatchLazyLoad.java
@@ -1,10 +1,10 @@
 package org.tests.inheritance;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Car;
 import org.tests.model.basic.Truck;
 import org.tests.model.basic.Vehicle;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -19,15 +19,15 @@ public class TestInheritanceBatchLazyLoad {
     Car c = new Car();
     c.setLicenseNumber("VZVZ1");
     c.setDriver("CarDriver");
-    Ebean.save(c);
+    DB.save(c);
 
     Truck t = new Truck();
     t.setLicenseNumber("VZVZ2");
     t.setCapacity(20D);
-    Ebean.save(t);
+    DB.save(t);
 
 
-    List<Vehicle> list = Ebean.find(Vehicle.class)
+    List<Vehicle> list = DB.find(Vehicle.class)
       .select("licenseNumber")
       .where().startsWith("licenseNumber", "VZVZ")
       .order().asc("licenseNumber")
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceDiscriminatorQueryCache.java b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceDiscriminatorQueryCache.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/inheritance/TestInheritanceDiscriminatorQueryCache.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestInheritanceDiscriminatorQueryCache.java
index 9bcdad41b..a0875a694 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceDiscriminatorQueryCache.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceDiscriminatorQueryCache.java
@@ -1,9 +1,9 @@
 package org.tests.inheritance;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
 import org.tests.inheritance.model.GroupConfiguration;
 import org.tests.inheritance.model.ProductConfiguration;
 
@@ -13,7 +13,7 @@ public class TestInheritanceDiscriminatorQueryCache extends BaseTestCase {
 
   @Test
   public void testDiscriminatorQueryCache() {
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     ProductConfiguration pc1 = new ProductConfiguration();
     pc1.setName("PC1");
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceJoins.java b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceJoins.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/inheritance/TestInheritanceJoins.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestInheritanceJoins.java
index 695bc09d0..deb32300f 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceJoins.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceJoins.java
@@ -3,10 +3,7 @@ package org.tests.inheritance;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Database;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.inheritance.model.CalculationResult;
 import org.tests.inheritance.model.Configurations;
 import org.tests.inheritance.model.GroupConfiguration;
@@ -15,12 +12,14 @@ import org.tests.inheritance.model.ProductConfiguration;
 import java.util.Collections;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestInheritanceJoins extends BaseTestCase {
 
   @Test
   public void testAssocOne() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     ProductConfiguration pc = new ProductConfiguration();
     pc.setName("PC1");
@@ -40,7 +39,7 @@ public class TestInheritanceJoins extends BaseTestCase {
   @Test
   public void assocOne_when_null() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
     GroupConfiguration gc = new GroupConfiguration();
     gc.setName("GC1");
@@ -57,7 +56,7 @@ public class TestInheritanceJoins extends BaseTestCase {
     CalculationResult result = server.find(CalculationResult.class, r.getId());
 
     GroupConfiguration group = result.getGroupConfiguration();
-    Assert.assertEquals(group.getId(), gc.getId());
+    assertEquals(group.getId(), gc.getId());
   }
 
   @Test
@@ -65,7 +64,7 @@ public class TestInheritanceJoins extends BaseTestCase {
 
 		/* Ensures the fetch join to a property with inheritance work as a left join */
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     final ProductConfiguration pc = new ProductConfiguration();
     pc.setName("PC1");
@@ -83,7 +82,7 @@ public class TestInheritanceJoins extends BaseTestCase {
   public void testAssocMany() {
     Configurations configurations = new Configurations();
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     server.save(configurations);
 
@@ -99,20 +98,20 @@ public class TestInheritanceJoins extends BaseTestCase {
 
     List<GroupConfiguration> groups = configurationsQueried.getGroupConfigurations();
 
-    Assert.assertTrue(!groups.isEmpty());
+    assertTrue(!groups.isEmpty());
   }
 
   @Test
   public void testAssocManyWithNoneRelated() {
     Configurations configurations = new Configurations();
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     server.save(configurations);
 
     Configurations configurationsQueried = server.find(Configurations.class).fetch("groupConfigurations").where().idEq(configurations.getId()).findOne();
 
-    Assert.assertNotNull(configurationsQueried);
+    assertNotNull(configurationsQueried);
   }
 
   @Test
@@ -132,8 +131,8 @@ public class TestInheritanceJoins extends BaseTestCase {
 
     Configurations configurationsQueried = database.find(Configurations.class).fetch("groupConfigurations").fetch("productConfigurations").where().idEq(configurations.getId()).findOne();
 
-    Assert.assertEquals(Collections.singletonList(gc), configurationsQueried.getGroupConfigurations());
-    Assert.assertEquals(Collections.singletonList(pc), configurationsQueried.getProductConfigurations());
+    assertEquals(Collections.singletonList(gc), configurationsQueried.getGroupConfigurations());
+    assertEquals(Collections.singletonList(pc), configurationsQueried.getProductConfigurations());
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceOnMany.java b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceOnMany.java
similarity index 64%
rename from ebean-core/src/test/java/org/tests/inheritance/TestInheritanceOnMany.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestInheritanceOnMany.java
index 1a0bc812c..1be175266 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceOnMany.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceOnMany.java
@@ -1,22 +1,18 @@
 package org.tests.inheritance;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.BeanCollection.ModifyListenMode;
 import io.ebean.common.BeanList;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
-import org.tests.model.basic.Animal;
-import org.tests.model.basic.AnimalShelter;
-import org.tests.model.basic.BigDog;
-import org.tests.model.basic.Cat;
-import org.tests.model.basic.Dog;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestInheritanceOnMany extends BaseTestCase {
 
@@ -25,25 +21,25 @@ public class TestInheritanceOnMany extends BaseTestCase {
 
     Cat cat = new Cat();
     cat.setName("Puss");
-    Ebean.save(cat);
+    DB.save(cat);
 
     Dog dog = new Dog();
     dog.setRegistrationNumber("DOGGIE");
-    Ebean.save(dog);
+    DB.save(dog);
 
     BigDog bd = new BigDog();
     bd.setDogSize("large");
     bd.setRegistrationNumber("BG1");
-    Ebean.save(bd);
+    DB.save(bd);
 
     AnimalShelter shelter = new AnimalShelter();
     shelter.setName("My Animal Shelter");
     shelter.getAnimals().add(cat);
     shelter.getAnimals().add(dog);
 
-    Ebean.save(shelter);
+    DB.save(shelter);
 
-    AnimalShelter shelter2 = Ebean.find(AnimalShelter.class, shelter.getId());
+    AnimalShelter shelter2 = DB.find(AnimalShelter.class, shelter.getId());
     List<Animal> animals = shelter2.getAnimals();
 
     BeanList<?> beanList = (BeanList<?>) animals;
@@ -51,7 +47,7 @@ public class TestInheritanceOnMany extends BaseTestCase {
 
     assertNotNull(modifyListenMode);
 
-    assertNotNull(Ebean.find(Animal.class).findList());
+    assertNotNull(DB.find(Animal.class).findList());
   }
 
   @Test
@@ -59,14 +55,14 @@ public class TestInheritanceOnMany extends BaseTestCase {
 
     Dog dog = new Dog();
     dog.setRegistrationNumber("D2");
-    Ebean.save(dog);
+    DB.save(dog);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     // Dog is concrete so we return as Dog even though
     // it could be a BigDog (so we are trusting the caller)
-    Dog ref = Ebean.getReference(Dog.class, dog.getId());
+    Dog ref = DB.reference(Dog.class, dog.getId());
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).isEmpty();
     assertNotNull(ref);
 
@@ -80,12 +76,12 @@ public class TestInheritanceOnMany extends BaseTestCase {
     BigDog bd = new BigDog();
     bd.setDogSize("large");
     bd.setRegistrationNumber("BG2");
-    Ebean.save(bd);
+    DB.save(bd);
 
-    LoggedSqlCollector.start();
-    BigDog bigDog = Ebean.getReference(BigDog.class, bd.getId());
+    LoggedSql.start();
+    BigDog bigDog = DB.reference(BigDog.class, bd.getId());
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).isEmpty();
     assertNotNull(bigDog);
 
@@ -93,11 +89,11 @@ public class TestInheritanceOnMany extends BaseTestCase {
     assertEquals("BG2", bigDog.getRegistrationNumber());
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     // Animal is abstract so we hit the DB
-    Animal animal = Ebean.getReference(Animal.class, bd.getId());
+    Animal animal = DB.reference(Animal.class, bd.getId());
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertThat(trimSql(sql.get(0), 2)).contains("select t0.species, t0.id from animal t0 where t0.id = ?");
     assertNotNull(animal);
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceOrderColumn.java b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceOrderColumn.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/inheritance/TestInheritanceOrderColumn.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestInheritanceOrderColumn.java
index dd6ef5832..57e36f9f6 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceOrderColumn.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceOrderColumn.java
@@ -1,10 +1,9 @@
 package org.tests.inheritance;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebeantest.LoggedSql;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.inheritance.order.OrderMasterInheritance;
 import org.tests.inheritance.order.OrderedA;
 import org.tests.inheritance.order.OrderedB;
@@ -30,9 +29,9 @@ public class TestInheritanceOrderColumn extends BaseTestCase {
     master.getReferenced().add(orderedA);
     master.getReferenced().add(orderedB);
 
-    LoggedSqlCollector.start();
-    Ebean.save(master);
-    List<String> sql = LoggedSqlCollector.stop();
+    LoggedSql.start();
+    DB.save(master);
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(5);
     // Some platforms insert ids and others don't need to...
     assertSql(trimId(sql, 1))
@@ -40,7 +39,7 @@ public class TestInheritanceOrderColumn extends BaseTestCase {
     assertSql(trimId(sql, 3))
       .contains("insert into ordered_parent (order_master_inheritance_id, dtype, common_name, ordered_bname, sort_order) values");
 
-    OrderMasterInheritance result = Ebean.find(OrderMasterInheritance.class).findOne();
+    OrderMasterInheritance result = DB.find(OrderMasterInheritance.class).findOne();
     assertThat(result.getReferenced())
       .extracting(OrderedParent::getCommonName)
       .containsExactly("commonOrderedA", "commonOrderedB");
@@ -52,12 +51,12 @@ public class TestInheritanceOrderColumn extends BaseTestCase {
       .containsExactly("commonOrderedB", "commonOrderedA");
 
     LoggedSql.start();
-    Ebean.save(result);
-    sql = LoggedSqlCollector.stop();
+    DB.save(result);
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     assertThat(sql.get(0)).contains("update ordered_parent set sort_order=? where id=?");
 
-    result = Ebean.find(OrderMasterInheritance.class).findOne();
+    result = DB.find(OrderMasterInheritance.class).findOne();
     assertThat(result.getReferenced())
       .extracting(OrderedParent::getCommonName)
       .containsExactly("commonOrderedB", "commonOrderedA");
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceQuery.java b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceQuery.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/inheritance/TestInheritanceQuery.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestInheritanceQuery.java
index 3d16b0e46..dec3ecb53 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceQuery.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceQuery.java
@@ -1,10 +1,10 @@
 package org.tests.inheritance;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.inherit.ChildA;
 import org.tests.inherit.ChildB;
 import org.tests.inherit.Parent;
@@ -27,9 +27,9 @@ public class TestInheritanceQuery extends BaseTestCase {
     server().save(b2);
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Query<Parent> query = Ebean.find(Parent.class);
+    Query<Parent> query = DB.find(Parent.class);
 
     query.where().in("val", 90, 91); // restrict to a & b1
 
@@ -43,17 +43,17 @@ public class TestInheritanceQuery extends BaseTestCase {
     query2.setInheritType(ChildB.class);
     assertThat(query2.findList()).containsExactly(b1);
 
-    query2 = Ebean.find(Parent.class).setInheritType(ChildB.class);
+    query2 = DB.find(Parent.class).setInheritType(ChildB.class);
     assertThat(query2.findList()).contains(b1, b2);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(4);
     assertSql(sql.get(1)).contains("where t0.type = 'A'");
     assertSql(sql.get(2)).contains("where t0.type = 'B'");
     assertThat(sql.get(3)).contains("where t0.type = 'B'");
 
-    Ebean.delete(a);
-    Ebean.delete(b1);
-    Ebean.delete(b2);
+    DB.delete(a);
+    DB.delete(b1);
+    DB.delete(b2);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceRawSql.java b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceRawSql.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/inheritance/TestInheritanceRawSql.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestInheritanceRawSql.java
index 040a5e424..6cbb1945f 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceRawSql.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceRawSql.java
@@ -1,11 +1,10 @@
 package org.tests.inheritance;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.RawSql;
 import io.ebean.RawSqlBuilder;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Truck;
 import org.tests.model.basic.Vehicle;
 import org.tests.model.basic.VehicleLeaseLong;
@@ -15,6 +14,8 @@ import java.time.LocalDate;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestInheritanceRawSql extends BaseTestCase {
 
@@ -25,7 +26,7 @@ public class TestInheritanceRawSql extends BaseTestCase {
     truck.setCapacity(50D);
     truck.setLicenseNumber("ASB23");
 
-    Ebean.save(truck);
+    DB.save(truck);
 
 
     String sql = "select dtype, id, license_number from vehicle where id = :id";
@@ -33,24 +34,24 @@ public class TestInheritanceRawSql extends BaseTestCase {
 
     RawSql rawSql = rawSqlBuilder.create();
 
-    List<Vehicle> list = Ebean.find(Vehicle.class)
+    List<Vehicle> list = DB.find(Vehicle.class)
       .setRawSql(rawSql)
       .setParameter("id", truck.getId())
       .findList();
 
-    Assert.assertEquals(1, list.size());
+    assertEquals(1, list.size());
 
     Vehicle vehicle2 = list.get(0);
-    Assert.assertTrue(vehicle2 instanceof Truck);
+    assertTrue(vehicle2 instanceof Truck);
 
     Truck truck2 = (Truck) vehicle2;
-    Assert.assertEquals("ASB23", truck2.getLicenseNumber());
+    assertEquals("ASB23", truck2.getLicenseNumber());
 
     // invoke lazy loading and set the capacity
     truck2.setCapacity(30D);
 
     // and now save
-    Ebean.save(truck2);
+    DB.save(truck2);
   }
 
   @Test
@@ -62,7 +63,7 @@ public class TestInheritanceRawSql extends BaseTestCase {
     longLease.setMinDuration(100);
     longLease.setActiveEnd(LocalDate.now());
 
-    Ebean.save(longLease);
+    DB.save(longLease);
 
 
     Truck truck = new Truck();
@@ -70,7 +71,7 @@ public class TestInheritanceRawSql extends BaseTestCase {
     truck.setLicenseNumber("ZK1");
     truck.setLease(longLease);
 
-    Ebean.save(truck);
+    DB.save(truck);
 
 
     String sql = "select v.dtype, v.id, v.license_number, l.dtype, l.id, l.name " +
@@ -83,7 +84,7 @@ public class TestInheritanceRawSql extends BaseTestCase {
       .tableAliasMapping("l", "lease")
       .create();
 
-    Vehicle veh = Ebean.find(Vehicle.class)
+    Vehicle veh = DB.find(Vehicle.class)
       .setRawSql(rawSql)
       .setParameter(truck.getId())
       .findOne();
@@ -102,7 +103,7 @@ public class TestInheritanceRawSql extends BaseTestCase {
       .columnMapping("l.name", "lease.name")
       .create();
 
-    Vehicle veh2 = Ebean.find(Vehicle.class)
+    Vehicle veh2 = DB.find(Vehicle.class)
       .setRawSql(rawSql2)
       .setParameter(truck.getId())
       .findOne();
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceRefBean.java b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceRefBean.java
similarity index 55%
rename from ebean-core/src/test/java/org/tests/inheritance/TestInheritanceRefBean.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestInheritanceRefBean.java
index 520e84866..a041117ac 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestInheritanceRefBean.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestInheritanceRefBean.java
@@ -1,15 +1,14 @@
 package org.tests.inheritance;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import org.ebeantest.LoggedSqlCollector;
+import io.ebean.BaseTestCase;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.inherit.ChildA;
 import org.tests.inherit.ChildB;
 import org.tests.inherit.Parent;
-import org.junit.Test;
 
-import io.ebean.BaseTestCase;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestInheritanceRefBean extends BaseTestCase {
 
@@ -25,15 +24,15 @@ public class TestInheritanceRefBean extends BaseTestCase {
 
       Parent test;
 
-      LoggedSqlCollector.start();
-      test = server().getReference(ChildA.class, idA);
+      LoggedSql.start();
+      test = server().reference(ChildA.class, idA);
       assertTrue(test instanceof ChildA);
-      assertEquals(0, LoggedSqlCollector.stop().size());
+      assertEquals(0, LoggedSql.stop().size());
 
-      LoggedSqlCollector.start();
-      test = server().getReference(Parent.class, idB);
+      LoggedSql.start();
+      test = server().reference(Parent.class, idB);
       assertTrue(test instanceof ChildB);
-      assertEquals(1, LoggedSqlCollector.stop().size());
+      assertEquals(1, LoggedSql.stop().size());
 
 
     }
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestIntInherit.java b/ebean-test/src/test/java/org/tests/inheritance/TestIntInherit.java
similarity index 52%
rename from ebean-core/src/test/java/org/tests/inheritance/TestIntInherit.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestIntInherit.java
index 42a2bb210..a67d6a764 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestIntInherit.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestIntInherit.java
@@ -2,11 +2,12 @@ package org.tests.inheritance;
 
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TIntChild;
 import org.tests.model.basic.TIntRoot;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestIntInherit extends BaseTestCase {
 
@@ -28,19 +29,19 @@ public class TestIntInherit extends BaseTestCase {
     c2.setChildProperty("cp2");
 
 
-    Ebean.save(r);
-    Ebean.save(r2);
-    Ebean.save(c1);
-    Ebean.save(c2);
+    DB.save(r);
+    DB.save(r2);
+    DB.save(c1);
+    DB.save(c2);
 
-    TIntRoot result1 = Ebean.find(TIntRoot.class, r.getId());
-    Assert.assertTrue(result1 instanceof TIntRoot);
+    TIntRoot result1 = DB.find(TIntRoot.class, r.getId());
+    assertTrue(result1 instanceof TIntRoot);
 
-    TIntRoot ref3 = Ebean.getReference(TIntRoot.class, c1.getId());
-    Assert.assertTrue(ref3 instanceof TIntRoot);
+    TIntRoot ref3 = DB.reference(TIntRoot.class, c1.getId());
+    assertTrue(ref3 instanceof TIntRoot);
 
-    TIntRoot result3 = Ebean.find(TIntRoot.class, c1.getId());
-    Assert.assertTrue(result3 instanceof TIntChild);
+    TIntRoot result3 = DB.find(TIntRoot.class, c1.getId());
+    assertTrue(result3 instanceof TIntChild);
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestNpeOnDiscriminator.java b/ebean-test/src/test/java/org/tests/inheritance/TestNpeOnDiscriminator.java
similarity index 65%
rename from ebean-core/src/test/java/org/tests/inheritance/TestNpeOnDiscriminator.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestNpeOnDiscriminator.java
index 3dd088406..e365002fc 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestNpeOnDiscriminator.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestNpeOnDiscriminator.java
@@ -1,23 +1,23 @@
 package org.tests.inheritance;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 public class TestNpeOnDiscriminator extends BaseTestCase {
 
   @Test
   public void test() {
 
-    InnerReport report = Ebean.json().toBean(InnerReport.class, "{}");
-    Ebean.save(report);
+    InnerReport report = DB.json().toBean(InnerReport.class, "{}");
+    DB.save(report);
 
     // other service ...
     InnerReport.Forecast f = new InnerReport.Forecast();
     report.setForecast(f);
     f.innerReport = report;
 
-    Ebean.save(f);
+    DB.save(f);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestSkippable.java b/ebean-test/src/test/java/org/tests/inheritance/TestSkippable.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/inheritance/TestSkippable.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestSkippable.java
index 9f5448823..3f9f870ed 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestSkippable.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestSkippable.java
@@ -1,14 +1,15 @@
 package org.tests.inheritance;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.tests.model.basic.AttributeHolder;
 import org.tests.model.basic.ListAttribute;
 import org.tests.model.basic.ListAttributeValue;
-import org.junit.Assert;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestSkippable extends BaseTestCase {
 
@@ -27,26 +28,26 @@ public class TestSkippable extends BaseTestCase {
     final ListAttributeValue value1 = new ListAttributeValue();
     final ListAttributeValue value2 = new ListAttributeValue();
 
-    Ebean.save(value1);
-    Ebean.save(value2);
+    DB.save(value1);
+    DB.save(value2);
 
     final ListAttribute listAttribute = new ListAttribute();
     listAttribute.add(value1);
-    Ebean.save(listAttribute);
+    DB.save(listAttribute);
     logger.info(" -- seeded data");
 
-    final ListAttribute listAttributeDB = Ebean.find(ListAttribute.class, listAttribute.getId());
-    Assert.assertNotNull(listAttributeDB);
+    final ListAttribute listAttributeDB = DB.find(ListAttribute.class, listAttribute.getId());
+    assertNotNull(listAttributeDB);
 
     final ListAttributeValue value1_DB = listAttributeDB.getValues().iterator().next();
-    Assert.assertTrue(value1.getId().equals(value1_DB.getId()));
+    assertTrue(value1.getId().equals(value1_DB.getId()));
     logger.info(" -- asserted data in db");
 
 
     final AttributeHolder holder = new AttributeHolder();
     holder.add(listAttributeDB);
 
-    Ebean.save(holder);
+    DB.save(holder);
     logger.info(" -- saved holder");
 
     // Now change the M2M listAttribute.values and save the holder
@@ -56,19 +57,19 @@ public class TestSkippable extends BaseTestCase {
     listAttributeDB.add(value2);
 
     // Save the holder - should cascade down to the listAtribute and save the values
-    Ebean.save(holder);
+    DB.save(holder);
     logger.info(" -- M2M detected delete of value1 and add of value2 ?");
 
 
-    final ListAttribute listAttributeDB_2 = Ebean.find(ListAttribute.class, listAttributeDB.getId());
-    Assert.assertNotNull(listAttributeDB_2);
+    final ListAttribute listAttributeDB_2 = DB.find(ListAttribute.class, listAttributeDB.getId());
+    assertNotNull(listAttributeDB_2);
     final ListAttributeValue value2_DB_2 = listAttributeDB_2.getValues().iterator().next();
 
 
-    Assert.assertEquals(value2.getId(), value2_DB_2.getId());
-    Assert.assertTrue("Cascade failed", value2.getId().equals(value2_DB_2.getId()));
+    assertEquals(value2.getId(), value2_DB_2.getId());
+    assertTrue(value2.getId().equals(value2_DB_2.getId()));
 
-    Ebean.delete(listAttributeDB_2);
+    DB.delete(listAttributeDB_2);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/inheritance/TestTreeOrganisations.java b/ebean-test/src/test/java/org/tests/inheritance/TestTreeOrganisations.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/inheritance/TestTreeOrganisations.java
rename to ebean-test/src/test/java/org/tests/inheritance/TestTreeOrganisations.java
index 3bdc08d8a..b9391055c 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/TestTreeOrganisations.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/TestTreeOrganisations.java
@@ -1,11 +1,10 @@
 package org.tests.inheritance;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestTreeOrganisations extends BaseTestCase {
 
@@ -19,9 +18,9 @@ public class TestTreeOrganisations extends BaseTestCase {
     node.setTitle("node");
 
     treeNode.setOrganizationNode(node);
-    Ebean.save(treeNode);
+    DB.save(treeNode);
 
-    treeNode = Ebean.find(OrganizationTreeNode.class, treeNode.getId());
+    treeNode = DB.find(OrganizationTreeNode.class, treeNode.getId());
     assertEquals(node, treeNode.getOrganizationNode());
 
   }
diff --git a/ebean-core/src/test/java/org/tests/inheritance/abstrakt/AbstractBaseBlock.java b/ebean-test/src/test/java/org/tests/inheritance/abstrakt/AbstractBaseBlock.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/inheritance/abstrakt/AbstractBaseBlock.java
rename to ebean-test/src/test/java/org/tests/inheritance/abstrakt/AbstractBaseBlock.java
index 334752405..c4c3d0202 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/abstrakt/AbstractBaseBlock.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/abstrakt/AbstractBaseBlock.java
@@ -1,12 +1,6 @@
 package org.tests.inheritance.abstrakt;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "block")
diff --git a/ebean-core/src/test/java/org/tests/inheritance/abstrakt/Block.java b/ebean-test/src/test/java/org/tests/inheritance/abstrakt/Block.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/abstrakt/Block.java
rename to ebean-test/src/test/java/org/tests/inheritance/abstrakt/Block.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/abstrakt/TestInheritanceNum.java b/ebean-test/src/test/java/org/tests/inheritance/abstrakt/TestInheritanceNum.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/inheritance/abstrakt/TestInheritanceNum.java
rename to ebean-test/src/test/java/org/tests/inheritance/abstrakt/TestInheritanceNum.java
index 42f36d263..8e9e2a6aa 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/abstrakt/TestInheritanceNum.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/abstrakt/TestInheritanceNum.java
@@ -1,8 +1,8 @@
 package org.tests.inheritance.abstrakt;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 public class TestInheritanceNum extends BaseTestCase {
 
@@ -13,6 +13,6 @@ public class TestInheritanceNum extends BaseTestCase {
     block.setName("ibe");
     block.setNotes("try it");
 
-    Ebean.save(block);
+    DB.save(block);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/inheritance/bothsides/SourceA.java b/ebean-test/src/test/java/org/tests/inheritance/bothsides/SourceA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/bothsides/SourceA.java
rename to ebean-test/src/test/java/org/tests/inheritance/bothsides/SourceA.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/bothsides/SourceB.java b/ebean-test/src/test/java/org/tests/inheritance/bothsides/SourceB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/bothsides/SourceB.java
rename to ebean-test/src/test/java/org/tests/inheritance/bothsides/SourceB.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/bothsides/SourceBase.java b/ebean-test/src/test/java/org/tests/inheritance/bothsides/SourceBase.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/bothsides/SourceBase.java
rename to ebean-test/src/test/java/org/tests/inheritance/bothsides/SourceBase.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/bothsides/Target1.java b/ebean-test/src/test/java/org/tests/inheritance/bothsides/Target1.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/bothsides/Target1.java
rename to ebean-test/src/test/java/org/tests/inheritance/bothsides/Target1.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/bothsides/Target2.java b/ebean-test/src/test/java/org/tests/inheritance/bothsides/Target2.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/bothsides/Target2.java
rename to ebean-test/src/test/java/org/tests/inheritance/bothsides/Target2.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/bothsides/TargetBase.java b/ebean-test/src/test/java/org/tests/inheritance/bothsides/TargetBase.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/bothsides/TargetBase.java
rename to ebean-test/src/test/java/org/tests/inheritance/bothsides/TargetBase.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/bothsides/TestInheritanceBothSides.java b/ebean-test/src/test/java/org/tests/inheritance/bothsides/TestInheritanceBothSides.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/inheritance/bothsides/TestInheritanceBothSides.java
rename to ebean-test/src/test/java/org/tests/inheritance/bothsides/TestInheritanceBothSides.java
index 788e9cf28..40c75b695 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/bothsides/TestInheritanceBothSides.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/bothsides/TestInheritanceBothSides.java
@@ -4,8 +4,8 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Database;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.stream.Collectors;
@@ -57,8 +57,8 @@ public class TestInheritanceBothSides extends BaseTestCase {
 
     final Database db = DB.getDefault();
 
-    final SourceBase foundA = DB.find(SourceBase.class, db.getBeanId(sourceA));
-    final SourceBase foundB = DB.find(SourceBase.class, db.getBeanId(sourceB));
+    final SourceBase foundA = DB.find(SourceBase.class, db.beanId(sourceA));
+    final SourceBase foundB = DB.find(SourceBase.class, db.beanId(sourceB));
 
     assertSourceBaseEqual(foundA, sourceA);
     assertThat(foundA).isInstanceOf(SourceA.class);
@@ -74,7 +74,7 @@ public class TestInheritanceBothSides extends BaseTestCase {
 
   private void assertFetchAllSourceAs() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     final List<SourceA> sourceAList = DB.find(SourceA.class)
       .fetch("target", "name")
@@ -87,7 +87,7 @@ public class TestInheritanceBothSides extends BaseTestCase {
 
     assertThat(joinedNames).isEqualTo("|source a|target 1|source a2|target 1b");
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.dtype, t0.id, t0.name, t0.pos, t1.dtype, t1.id, t1.name from source_base t0 left join target_base t1 on t1.id = t0.target_id and t1.dtype = 'Target1' where t0.dtype = 'SourceA' order by t0.pos");
   }
@@ -97,7 +97,7 @@ public class TestInheritanceBothSides extends BaseTestCase {
    */
   private void assertFetchAllDoubleLazyLoading() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     final List<SourceBase> sources = DB.find(SourceBase.class).order("pos").findList();
     for (SourceBase source : sources) {
@@ -113,7 +113,7 @@ public class TestInheritanceBothSides extends BaseTestCase {
       }
     }
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(3);
     //assertSql(sql.get(0)).contains("select t0.dtype, t0.id, t0.name, t0.pos, t0.target_id, t0.target_id from source_base t0 order by t0.pos");
diff --git a/ebean-core/src/test/java/org/tests/inheritance/bothsides/WithAutoGeneratedUUID.java b/ebean-test/src/test/java/org/tests/inheritance/bothsides/WithAutoGeneratedUUID.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/bothsides/WithAutoGeneratedUUID.java
rename to ebean-test/src/test/java/org/tests/inheritance/bothsides/WithAutoGeneratedUUID.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cache/CIAddress.java b/ebean-test/src/test/java/org/tests/inheritance/cache/CIAddress.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/cache/CIAddress.java
rename to ebean-test/src/test/java/org/tests/inheritance/cache/CIAddress.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cache/CIBaseModel.java b/ebean-test/src/test/java/org/tests/inheritance/cache/CIBaseModel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/cache/CIBaseModel.java
rename to ebean-test/src/test/java/org/tests/inheritance/cache/CIBaseModel.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cache/CICustomer.java b/ebean-test/src/test/java/org/tests/inheritance/cache/CICustomer.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/cache/CICustomer.java
rename to ebean-test/src/test/java/org/tests/inheritance/cache/CICustomer.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cache/CICustomerParent.java b/ebean-test/src/test/java/org/tests/inheritance/cache/CICustomerParent.java
similarity index 61%
rename from ebean-core/src/test/java/org/tests/inheritance/cache/CICustomerParent.java
rename to ebean-test/src/test/java/org/tests/inheritance/cache/CICustomerParent.java
index fdcbf0a3f..7e376add8 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/cache/CICustomerParent.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/cache/CICustomerParent.java
@@ -1,12 +1,6 @@
 package org.tests.inheritance.cache;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 
 @Entity
 @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cache/CIStreet.java b/ebean-test/src/test/java/org/tests/inheritance/cache/CIStreet.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/cache/CIStreet.java
rename to ebean-test/src/test/java/org/tests/inheritance/cache/CIStreet.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cache/CIStreetParent.java b/ebean-test/src/test/java/org/tests/inheritance/cache/CIStreetParent.java
similarity index 62%
rename from ebean-core/src/test/java/org/tests/inheritance/cache/CIStreetParent.java
rename to ebean-test/src/test/java/org/tests/inheritance/cache/CIStreetParent.java
index 9ea1f90a7..88b2de299 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/cache/CIStreetParent.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/cache/CIStreetParent.java
@@ -1,11 +1,6 @@
 package org.tests.inheritance.cache;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
+import javax.persistence.*;
 
 @Entity
 @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cache/TestInheritCacheRefLoad.java b/ebean-test/src/test/java/org/tests/inheritance/cache/TestInheritCacheRefLoad.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/inheritance/cache/TestInheritCacheRefLoad.java
rename to ebean-test/src/test/java/org/tests/inheritance/cache/TestInheritCacheRefLoad.java
index 0f79a4206..9b533afd9 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/cache/TestInheritCacheRefLoad.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/cache/TestInheritCacheRefLoad.java
@@ -1,8 +1,9 @@
 package org.tests.inheritance.cache;
 
 import io.ebean.DB;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestInheritCacheRefLoad {
 
@@ -29,17 +30,17 @@ public class TestInheritCacheRefLoad {
     // 2 - Read Data (no Cache Hit)
     //=========================================================================
     Class streetClass = reloadCustomer(customer, false);  //returns Street -> OK
-    Assert.assertEquals("org.tests.inheritance.cache.CIStreet", streetClass.getName());
+    assertEquals("org.tests.inheritance.cache.CIStreet", streetClass.getName());
     streetClass = reloadCustomer(customer, false);  //returns Street -> OK
-    Assert.assertEquals("org.tests.inheritance.cache.CIStreet", streetClass.getName());
+    assertEquals("org.tests.inheritance.cache.CIStreet", streetClass.getName());
 
     //=========================================================================
     // 3 - Read Data (L2-Cache Hit)
     //=========================================================================
     streetClass = reloadCustomer(customer, true); //returns Street -> OK
-    Assert.assertEquals("org.tests.inheritance.cache.CIStreet", streetClass.getName());
+    assertEquals("org.tests.inheritance.cache.CIStreet", streetClass.getName());
     streetClass = reloadCustomer(customer, true); //returns StreetParent -> NOT OK
-    Assert.assertEquals("org.tests.inheritance.cache.CIStreet", streetClass.getName());
+    assertEquals("org.tests.inheritance.cache.CIStreet", streetClass.getName());
   }
 
 
@@ -56,7 +57,7 @@ public class TestInheritCacheRefLoad {
     Class streetClassLazyLoaded = customerReloaded.getAddress().getStreet().getClass();
 
     //Show Cache Hits
-    System.out.println("Class of Street (Cache on: " + l2Cache + "): " + streetClassLazyLoaded + " | Cache Hit: " + DB.getDefault().getServerCacheManager().getQueryCache(streetClassLazyLoaded).getStatistics(false).getHitCount());
+    System.out.println("Class of Street (Cache on: " + l2Cache + "): " + streetClassLazyLoaded + " | Cache Hit: " + DB.getDefault().cacheManager().queryCache(streetClassLazyLoaded).statistics(false).getHitCount());
     return streetClassLazyLoaded;
   }
 
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cache/TestInheritanceCache.java b/ebean-test/src/test/java/org/tests/inheritance/cache/TestInheritanceCache.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/inheritance/cache/TestInheritanceCache.java
rename to ebean-test/src/test/java/org/tests/inheritance/cache/TestInheritanceCache.java
index f4161d79e..aea64c388 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/cache/TestInheritanceCache.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/cache/TestInheritanceCache.java
@@ -2,10 +2,10 @@ package org.tests.inheritance.cache;
 
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.cache.CInhOne;
 import org.tests.model.basic.cache.CInhRoot;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -19,24 +19,24 @@ public class TestInheritanceCache extends BaseTestCase {
     one.setDriver("Jimmy");
     one.setNotes("Hello");
 
-    Ebean.save(one);
+    DB.save(one);
 
-    CInhRoot gotOne = Ebean.find(CInhRoot.class)
+    CInhRoot gotOne = DB.find(CInhRoot.class)
       .setId(one.getId())
       .findOne();
 
     assertThat(gotOne).isInstanceOf(CInhOne.class);
 
-    CInhRoot gotOneFromCache = Ebean.find(CInhRoot.class)
+    CInhRoot gotOneFromCache = DB.find(CInhRoot.class)
       .setId(one.getId())
       .findOne();
 
     assertThat(gotOneFromCache).isInstanceOf(CInhOne.class);
 
-    CInhRoot refOne = Ebean.getReference(CInhRoot.class, one.getId());
+    CInhRoot refOne = DB.reference(CInhRoot.class, one.getId());
     assertThat(refOne).isInstanceOf(CInhOne.class);
 
-    CInhRoot refOneSub = Ebean.getReference(CInhOne.class, one.getId());
+    CInhRoot refOneSub = DB.reference(CInhOne.class, one.getId());
     assertThat(refOneSub).isNotNull();
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cache/TestInheritanceRefCache.java b/ebean-test/src/test/java/org/tests/inheritance/cache/TestInheritanceRefCache.java
similarity index 61%
rename from ebean-core/src/test/java/org/tests/inheritance/cache/TestInheritanceRefCache.java
rename to ebean-test/src/test/java/org/tests/inheritance/cache/TestInheritanceRefCache.java
index ad104db21..d341db918 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/cache/TestInheritanceRefCache.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/cache/TestInheritanceRefCache.java
@@ -1,9 +1,9 @@
 package org.tests.inheritance.cache;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.cache.CInhOne;
 import org.tests.model.basic.cache.CInhRef;
 import org.tests.model.basic.cache.CInhRoot;
@@ -24,41 +24,41 @@ public class TestInheritanceRefCache extends BaseTestCase {
     one.setDriver("Jimmy");
     one.setNotes("Hello");
 
-    Ebean.save(one);
+    DB.save(one);
 
     CInhRef ref = new CInhRef();
     ref.setRef(one);
 
-    Ebean.save(ref);
+    DB.save(ref);
 
     Integer id = ref.getId();
 
-    LoggedSqlCollector.start();
-    CInhRef gotRef = Ebean.find(CInhRef.class).setId(id).findOne();
+    LoggedSql.start();
+    CInhRef gotRef = DB.find(CInhRef.class).setId(id).findOne();
 
     assertThat(gotRef).isInstanceOf(CInhRef.class);
     assertThat(gotRef.getRef()).isInstanceOf(CInhOne.class);
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("from cinh_ref").contains("left join cinh_root");
 
     // fetch again - from cache (but fetch second bean from cache)
-    LoggedSqlCollector.start();
-    gotRef = Ebean.find(CInhRef.class).setId(id).findOne();
+    LoggedSql.start();
+    gotRef = DB.find(CInhRef.class).setId(id).findOne();
 
     assertThat(gotRef).isInstanceOf(CInhRef.class);
     assertThat(gotRef.getRef()).isInstanceOf(CInhOne.class);
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(0);
 
 
     // fetch again - both from cache
-    LoggedSqlCollector.start();
-    gotRef = Ebean.find(CInhRef.class).setId(id).findOne();
+    LoggedSql.start();
+    gotRef = DB.find(CInhRef.class).setId(id).findOne();
 
     assertThat(gotRef).isInstanceOf(CInhRef.class);
     assertThat(gotRef.getRef()).isInstanceOf(CInhOne.class);
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(0);
 
   }
@@ -72,36 +72,36 @@ public class TestInheritanceRefCache extends BaseTestCase {
     one.setLicenseNumber("O19");
     one.setDriver("Foo");
     one.setNotes("Hello");
-    Ebean.save(one);
+    DB.save(one);
 
     ids.add(one.getId());
 
     CInhTwo two = new CInhTwo();
     two.setLicenseNumber("T23");
     two.setAction("Test");
-    Ebean.save(two);
+    DB.save(two);
 
     ids.add(two.getId());
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(CInhRoot.class).setUseQueryCache(true).where().idIn(ids).setMapKey("licenseNumber").findMap();
+    DB.find(CInhRoot.class).setUseQueryCache(true).where().idIn(ids).setMapKey("licenseNumber").findMap();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("from cinh_root");
 
     // try some cache finds
-    Ebean.find(CInhRoot.class).setUseQueryCache(true).findList();
-    Ebean.find(CInhRoot.class).setUseQueryCache(true).findList();
-    Ebean.find(CInhRoot.class).setUseQueryCache(true).findList();
+    DB.find(CInhRoot.class).setUseQueryCache(true).findList();
+    DB.find(CInhRoot.class).setUseQueryCache(true).findList();
+    DB.find(CInhRoot.class).setUseQueryCache(true).findList();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(CInhRoot.class).setUseQueryCache(true).where().idIn(ids).setMapKey("licenseNumber").findMap();
+    DB.find(CInhRoot.class).setUseQueryCache(true).where().idIn(ids).setMapKey("licenseNumber").findMap();
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(0);
   }
 
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cascadedelete/ComplexBean.java b/ebean-test/src/test/java/org/tests/inheritance/cascadedelete/ComplexBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/cascadedelete/ComplexBean.java
rename to ebean-test/src/test/java/org/tests/inheritance/cascadedelete/ComplexBean.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cascadedelete/ElementBean.java b/ebean-test/src/test/java/org/tests/inheritance/cascadedelete/ElementBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/cascadedelete/ElementBean.java
rename to ebean-test/src/test/java/org/tests/inheritance/cascadedelete/ElementBean.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cascadedelete/ReferencingBean.java b/ebean-test/src/test/java/org/tests/inheritance/cascadedelete/ReferencingBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/cascadedelete/ReferencingBean.java
rename to ebean-test/src/test/java/org/tests/inheritance/cascadedelete/ReferencingBean.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cascadedelete/RootBean.java b/ebean-test/src/test/java/org/tests/inheritance/cascadedelete/RootBean.java
similarity index 58%
rename from ebean-core/src/test/java/org/tests/inheritance/cascadedelete/RootBean.java
rename to ebean-test/src/test/java/org/tests/inheritance/cascadedelete/RootBean.java
index d9d9ab08e..76d9ddc0c 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/cascadedelete/RootBean.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/cascadedelete/RootBean.java
@@ -1,10 +1,6 @@
 package org.tests.inheritance.cascadedelete;
 
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.PreRemove;
+import javax.persistence.*;
 import java.util.UUID;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cascadedelete/SimpleBean.java b/ebean-test/src/test/java/org/tests/inheritance/cascadedelete/SimpleBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/cascadedelete/SimpleBean.java
rename to ebean-test/src/test/java/org/tests/inheritance/cascadedelete/SimpleBean.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/cascadedelete/TestInheritanceDeleteCascade.java b/ebean-test/src/test/java/org/tests/inheritance/cascadedelete/TestInheritanceDeleteCascade.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/inheritance/cascadedelete/TestInheritanceDeleteCascade.java
rename to ebean-test/src/test/java/org/tests/inheritance/cascadedelete/TestInheritanceDeleteCascade.java
index e4da9b23d..b11abf5ed 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/cascadedelete/TestInheritanceDeleteCascade.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/cascadedelete/TestInheritanceDeleteCascade.java
@@ -2,10 +2,10 @@ package org.tests.inheritance.cascadedelete;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static java.util.Arrays.asList;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestInheritanceDeleteCascade extends BaseTestCase {
 
@@ -19,8 +19,8 @@ public class TestInheritanceDeleteCascade extends BaseTestCase {
     DB.save(referencingBean);
     DB.delete(referencingBean);
 
-    assertNull(DB.find(RootBean.class, DB.getBeanId(bean1)));
-    assertNull(DB.find(RootBean.class, DB.getBeanId(bean2)));
+    assertNull(DB.find(RootBean.class, DB.beanId(bean1)));
+    assertNull(DB.find(RootBean.class, DB.beanId(bean2)));
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/inheritance/company/domain/AbstractBar.java b/ebean-test/src/test/java/org/tests/inheritance/company/domain/AbstractBar.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/inheritance/company/domain/AbstractBar.java
rename to ebean-test/src/test/java/org/tests/inheritance/company/domain/AbstractBar.java
index 0f580744a..899381d4e 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/company/domain/AbstractBar.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/company/domain/AbstractBar.java
@@ -1,17 +1,6 @@
 package org.tests.inheritance.company.domain;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 /**
  * @author Per-Ingemar Andersson, It-huset i Norden AB
diff --git a/ebean-core/src/test/java/org/tests/inheritance/company/domain/ConcreteBar.java b/ebean-test/src/test/java/org/tests/inheritance/company/domain/ConcreteBar.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/company/domain/ConcreteBar.java
rename to ebean-test/src/test/java/org/tests/inheritance/company/domain/ConcreteBar.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/company/domain/Foo.java b/ebean-test/src/test/java/org/tests/inheritance/company/domain/Foo.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/inheritance/company/domain/Foo.java
rename to ebean-test/src/test/java/org/tests/inheritance/company/domain/Foo.java
index 8bc2dbf1a..5ef6ef7c8 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/company/domain/Foo.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/company/domain/Foo.java
@@ -1,10 +1,6 @@
 package org.tests.inheritance.company.domain;
 
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 /**
  * @author Per-Ingemar Andersson, It-huset i Norden AB
diff --git a/ebean-core/src/test/java/org/tests/inheritance/company/domain/TestInheritAbstract.java b/ebean-test/src/test/java/org/tests/inheritance/company/domain/TestInheritAbstract.java
similarity index 62%
rename from ebean-core/src/test/java/org/tests/inheritance/company/domain/TestInheritAbstract.java
rename to ebean-test/src/test/java/org/tests/inheritance/company/domain/TestInheritAbstract.java
index 4e4e5b64a..3d32d3d05 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/company/domain/TestInheritAbstract.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/company/domain/TestInheritAbstract.java
@@ -1,28 +1,31 @@
 package org.tests.inheritance.company.domain;
 
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import junit.framework.TestCase;
-import org.junit.Assert;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
-public class TestInheritAbstract extends TestCase {
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
+public class TestInheritAbstract {
+
+  @Test
   public void testMe() {
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     List<AbstractBar> list0 = server.find(AbstractBar.class)
       .findList();
 
-    Assert.assertNotNull(list0);
+    assertNotNull(list0);
 
     List<AbstractBar> list1 = server.find(AbstractBar.class)
       .fetch("foo", "importantText")
       .findList();
 
-    Assert.assertNotNull(list1);
+    assertNotNull(list1);
 
     Foo f = new Foo();
     f.setImportantText("blah");
@@ -37,13 +40,13 @@ public class TestInheritAbstract extends TestCase {
       .fetch("foo", "importantText")
       .findList();
 
-    Assert.assertNotNull(list2);
-    Assert.assertTrue(!list2.isEmpty());
+    assertNotNull(list2);
+    assertThat(list2).isNotEmpty();
 
     for (AbstractBar abstractBar : list2) {
       Foo foo = abstractBar.getFoo();
       String importantText = foo.getImportantText();
-      Assert.assertNotNull(importantText);
+      assertNotNull(importantText);
     }
 
 
diff --git a/ebean-core/src/test/java/org/tests/inheritance/model/AbstractBaseClass.java b/ebean-test/src/test/java/org/tests/inheritance/model/AbstractBaseClass.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/model/AbstractBaseClass.java
rename to ebean-test/src/test/java/org/tests/inheritance/model/AbstractBaseClass.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/model/CalculationResult.java b/ebean-test/src/test/java/org/tests/inheritance/model/CalculationResult.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/inheritance/model/CalculationResult.java
rename to ebean-test/src/test/java/org/tests/inheritance/model/CalculationResult.java
index 9cde2d7f3..6d315b65a 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/model/CalculationResult.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/model/CalculationResult.java
@@ -1,10 +1,6 @@
 package org.tests.inheritance.model;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 
 @Entity
 public class CalculationResult {
diff --git a/ebean-core/src/test/java/org/tests/inheritance/model/Configuration.java b/ebean-test/src/test/java/org/tests/inheritance/model/Configuration.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/model/Configuration.java
rename to ebean-test/src/test/java/org/tests/inheritance/model/Configuration.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/model/Configurations.java b/ebean-test/src/test/java/org/tests/inheritance/model/Configurations.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/model/Configurations.java
rename to ebean-test/src/test/java/org/tests/inheritance/model/Configurations.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/model/GroupConfiguration.java b/ebean-test/src/test/java/org/tests/inheritance/model/GroupConfiguration.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/model/GroupConfiguration.java
rename to ebean-test/src/test/java/org/tests/inheritance/model/GroupConfiguration.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/model/ProductConfiguration.java b/ebean-test/src/test/java/org/tests/inheritance/model/ProductConfiguration.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/model/ProductConfiguration.java
rename to ebean-test/src/test/java/org/tests/inheritance/model/ProductConfiguration.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/order/OrderMasterInheritance.java b/ebean-test/src/test/java/org/tests/inheritance/order/OrderMasterInheritance.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/inheritance/order/OrderMasterInheritance.java
rename to ebean-test/src/test/java/org/tests/inheritance/order/OrderMasterInheritance.java
index 408d764ff..e28fe6b66 100644
--- a/ebean-core/src/test/java/org/tests/inheritance/order/OrderMasterInheritance.java
+++ b/ebean-test/src/test/java/org/tests/inheritance/order/OrderMasterInheritance.java
@@ -1,10 +1,6 @@
 package org.tests.inheritance.order;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderColumn;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/inheritance/order/OrderedA.java b/ebean-test/src/test/java/org/tests/inheritance/order/OrderedA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/order/OrderedA.java
rename to ebean-test/src/test/java/org/tests/inheritance/order/OrderedA.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/order/OrderedB.java b/ebean-test/src/test/java/org/tests/inheritance/order/OrderedB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/order/OrderedB.java
rename to ebean-test/src/test/java/org/tests/inheritance/order/OrderedB.java
diff --git a/ebean-core/src/test/java/org/tests/inheritance/order/OrderedParent.java b/ebean-test/src/test/java/org/tests/inheritance/order/OrderedParent.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/inheritance/order/OrderedParent.java
rename to ebean-test/src/test/java/org/tests/inheritance/order/OrderedParent.java
diff --git a/ebean-core/src/test/java/org/tests/insert/EIdUidBean.java b/ebean-test/src/test/java/org/tests/insert/EIdUidBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/insert/EIdUidBean.java
rename to ebean-test/src/test/java/org/tests/insert/EIdUidBean.java
diff --git a/ebean-core/src/test/java/org/tests/insert/MainDbCopy.java b/ebean-test/src/test/java/org/tests/insert/MainDbCopy.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/insert/MainDbCopy.java
rename to ebean-test/src/test/java/org/tests/insert/MainDbCopy.java
index 094a5d321..1d6c0f1ea 100644
--- a/ebean-core/src/test/java/org/tests/insert/MainDbCopy.java
+++ b/ebean-test/src/test/java/org/tests/insert/MainDbCopy.java
@@ -1,7 +1,7 @@
 package org.tests.insert;
 
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import org.tests.model.basic.EBasic;
 import org.tests.model.basic.EBasic.Status;
 
@@ -9,7 +9,7 @@ public class MainDbCopy {
 
   public static void main(String[] args) {
 
-    EbeanServer defaultServer = Ebean.getServer(null);
+    Database defaultServer = DB.getDefault();
 
     EBasic e = new EBasic();
     e.setName("blah");
@@ -20,10 +20,7 @@ public class MainDbCopy {
 
     EBasic e1 = defaultServer.find(EBasic.class, e.getId());
 
-    EbeanServer serverDest = Ebean.getServer("mysql");
-
+    Database serverDest = DB.byName("mysql");
     serverDest.insert(e1);
-
-
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/insert/OnlyIdEntity.java b/ebean-test/src/test/java/org/tests/insert/OnlyIdEntity.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/insert/OnlyIdEntity.java
rename to ebean-test/src/test/java/org/tests/insert/OnlyIdEntity.java
diff --git a/ebean-core/src/test/java/org/tests/insert/TestInsertCheckUnique.java b/ebean-test/src/test/java/org/tests/insert/TestInsertCheckUnique.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/insert/TestInsertCheckUnique.java
rename to ebean-test/src/test/java/org/tests/insert/TestInsertCheckUnique.java
index a58e2b418..5f0a31039 100644
--- a/ebean-core/src/test/java/org/tests/insert/TestInsertCheckUnique.java
+++ b/ebean-test/src/test/java/org/tests/insert/TestInsertCheckUnique.java
@@ -4,8 +4,8 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.plugin.Property;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.tests.model.draftable.Document;
 
 import java.util.Set;
@@ -14,7 +14,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestInsertCheckUnique extends BaseTestCase {
 
-  @Before
+  @BeforeEach
   public void clearDb() {
     DB.find(Document.class).asDraft().where().contains("title", "UniqueKey").delete();
     DB.find(Document.class).asDraft().where().isNull("title").delete();
@@ -95,8 +95,8 @@ public class TestInsertCheckUnique extends BaseTestCase {
         StringBuilder msg = new StringBuilder();
 
         properties.forEach((it)-> {
-          Object propertyValue = it.getVal(doc2);
-          String propertyName = it.getName();
+          Object propertyValue = it.value(doc2);
+          String propertyName = it.name();
           msg.append(" property["+propertyName+"] value["+propertyValue+"]");
         });
 
diff --git a/ebean-test/src/test/java/org/tests/insert/TestInsertCollection.java b/ebean-test/src/test/java/org/tests/insert/TestInsertCollection.java
new file mode 100644
index 000000000..0d3679d91
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/insert/TestInsertCollection.java
@@ -0,0 +1,80 @@
+package org.tests.insert;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Customer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestInsertCollection extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Customer cust1 = new Customer();
+    cust1.setName("jim");
+
+    Customer cust2 = new Customer();
+    cust2.setName("bob");
+
+    List<Customer> customers = new ArrayList<>();
+    customers.add(cust1);
+    customers.add(cust2);
+
+    DB.insertAll(customers);
+
+    assertNotNull(cust1.getId());
+    assertNotNull(cust2.getId());
+
+    Customer cust1Check = DB.find(Customer.class, cust1.getId());
+    assertEquals(cust1.getName(), cust1Check.getName());
+    Customer cust2Check = DB.find(Customer.class, cust2.getId());
+    assertEquals(cust2.getName(), cust2Check.getName());
+
+    cust1.setName("jim-changed");
+    cust2.setName("bob-changed");
+
+    DB.updateAll(customers);
+    awaitL2Cache();
+
+    Customer cust1Check2 = DB.find(Customer.class, cust1.getId());
+    assertEquals("jim-changed", cust1Check2.getName());
+    Customer cust2Check2 = DB.find(Customer.class, cust2.getId());
+    assertEquals("bob-changed", cust2Check2.getName());
+
+
+    cust1Check2.setName("jim-updated");
+    Customer cust3 = new Customer();
+    cust3.setName("mac");
+
+    List<Customer> saveList = new ArrayList<>();
+    saveList.add(cust1Check2);
+    saveList.add(cust3);
+
+    DB.saveAll(saveList);
+    awaitL2Cache();
+
+
+    Customer cust1Check3 = DB.find(Customer.class, cust1.getId());
+    assertEquals("jim-updated", cust1Check3.getName());
+    Customer cust3Check = DB.find(Customer.class, cust3.getId());
+    assertEquals("mac", cust3Check.getName());
+
+    List<Customer> deleteList = new ArrayList<>();
+    deleteList.add(cust1Check3);
+    deleteList.add(cust3);
+    deleteList.add(cust2Check2);
+
+    DB.deleteAll(deleteList);
+    awaitL2Cache();
+
+    assertNull(DB.find(Customer.class, cust1Check3.getId()));
+    assertNull(DB.find(Customer.class, cust2Check2.getId()));
+    assertNull(DB.find(Customer.class, cust3.getId()));
+  }
+
+}
diff --git a/ebean-core/src/test/java/org/tests/insert/TestInsertDataIntegrityException.java b/ebean-test/src/test/java/org/tests/insert/TestInsertDataIntegrityException.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/insert/TestInsertDataIntegrityException.java
rename to ebean-test/src/test/java/org/tests/insert/TestInsertDataIntegrityException.java
index 539f05f8d..1794098e6 100644
--- a/ebean-core/src/test/java/org/tests/insert/TestInsertDataIntegrityException.java
+++ b/ebean-test/src/test/java/org/tests/insert/TestInsertDataIntegrityException.java
@@ -3,30 +3,30 @@ package org.tests.insert;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.DataIntegrityException;
-import io.ebean.Ebean;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 public class TestInsertDataIntegrityException extends BaseTestCase {
 
 
   @IgnorePlatform(Platform.NUODB)
-  @Test(expected = DataIntegrityException.class)
+  @Test
   public void insert_invalidForeignKey() {
-
     ResetBasicData.reset();
 
     // an invalid foreign key value
-    Customer invalidCustomer = Ebean.getReference(Customer.class, 900000);
+    Customer invalidCustomer = DB.reference(Customer.class, 900000);
 
     Order order = new Order();
     order.setStatus(Order.Status.NEW);
     order.setCustomer(invalidCustomer);
 
-    DB.save(order);
+    assertThrows(DataIntegrityException.class, () -> DB.save(order));
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/insert/TestInsertDuplicateKey.java b/ebean-test/src/test/java/org/tests/insert/TestInsertDuplicateKey.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/insert/TestInsertDuplicateKey.java
rename to ebean-test/src/test/java/org/tests/insert/TestInsertDuplicateKey.java
index 0c728eaa3..8682874dc 100644
--- a/ebean-core/src/test/java/org/tests/insert/TestInsertDuplicateKey.java
+++ b/ebean-test/src/test/java/org/tests/insert/TestInsertDuplicateKey.java
@@ -1,12 +1,11 @@
 package org.tests.insert;
 
 import io.ebean.BaseTestCase;
+import io.ebean.DB;
 import io.ebean.DuplicateKeyException;
-import io.ebean.Ebean;
 import io.ebean.annotation.Transactional;
-
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.draftable.Document;
@@ -15,46 +14,47 @@ import java.sql.SQLException;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class TestInsertDuplicateKey extends BaseTestCase {
 
   private static final Logger log = LoggerFactory.getLogger(TestInsertDuplicateKey.class);
 
-  @Before
+  @BeforeEach
   public void clearDb() {
     server().find(Document.class).asDraft().where().contains("title", "UniqueKey").delete();
   }
 
-  @Test(expected = DuplicateKeyException.class)
+  @Test
   public void insert_duplicateKey() {
-
     Document doc1 = new Document();
     doc1.setTitle("ThisIsAUniqueKey");
     doc1.setBody("one");
-
     doc1.save();
 
-    Document doc2 = new Document();
-    doc2.setTitle("ThisIsAUniqueKey");
-    doc2.setBody("clashes with doc1");
+    assertThrows(DuplicateKeyException.class, () -> {
+      Document doc2 = new Document();
+      doc2.setTitle("ThisIsAUniqueKey");
+      doc2.setBody("clashes with doc1");
+      doc2.save();
+    });
+  }
 
-    doc2.save();
+  @Test
+  public void insertBatch_duplicateKey() {
+    assertThrows(DuplicateKeyException.class, this::insertBatch_duplicateKey_action);
   }
 
   @Transactional(batchSize = 100)
-  @Test(expected = DuplicateKeyException.class)
-  public void insertBatch_duplicateKey() {
-
+  void insertBatch_duplicateKey_action() {
     Document doc1 = new Document();
     doc1.setTitle("ThisIsASecondUniqueKey");
     doc1.setBody("one");
-
     doc1.save();
 
     Document doc2 = new Document();
     doc2.setTitle("ThisIsASecondUniqueKey");
     doc2.setBody("clash when batch flushed");
-
     doc2.save();
   }
 
@@ -63,7 +63,7 @@ public class TestInsertDuplicateKey extends BaseTestCase {
 
     insertTheBatch_duplicateKey_catchAndContinue();
 
-    List<Document> found = Ebean.getDefaultServer()
+    List<Document> found = DB.getDefault()
       .find(Document.class)
       .asDraft()
       .where().startsWith("body", "insertTheBatch_duplicateKey_catchAndContinue")
@@ -89,14 +89,14 @@ public class TestInsertDuplicateKey extends BaseTestCase {
       doc2.save();
 
       // flush at this point, fails
-      Ebean.getDefaultServer().currentTransaction().flush();
+      DB.getDefault().currentTransaction().flush();
     } catch (DuplicateKeyException e) {
       log.info("duplicate failed but just continue" + e.getMessage());
       try {
         // typically we would use transaction.commitAndContinue()
         // ... this is a rollback and continue type scenario
         // ... more sensible to use a second transaction that do this
-        Ebean.getDefaultServer().currentTransaction().getConnection().rollback();
+        DB.getDefault().currentTransaction().connection().rollback();
       } catch (SQLException e1) {
         e1.printStackTrace();
       }
diff --git a/ebean-core/src/test/java/org/tests/insert/TestInsertOnStringKey.java b/ebean-test/src/test/java/org/tests/insert/TestInsertOnStringKey.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/insert/TestInsertOnStringKey.java
rename to ebean-test/src/test/java/org/tests/insert/TestInsertOnStringKey.java
index 1a856001d..436f2e6b4 100644
--- a/ebean-core/src/test/java/org/tests/insert/TestInsertOnStringKey.java
+++ b/ebean-test/src/test/java/org/tests/insert/TestInsertOnStringKey.java
@@ -1,10 +1,10 @@
 package org.tests.insert;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.orderentity.OrderEntity;
 import org.tests.model.orderentity.OrderItemEntity;
-import org.junit.Test;
 
 import java.math.BigDecimal;
 import java.util.ArrayList;
@@ -27,7 +27,7 @@ public class TestInsertOnStringKey extends BaseTestCase {
 
     orderEntity.setItems(toList(orderItemEntity));
 
-    Ebean.save(orderEntity);
+    DB.save(orderEntity);
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/insert/TestInsertWithIdAndUuid.java b/ebean-test/src/test/java/org/tests/insert/TestInsertWithIdAndUuid.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/insert/TestInsertWithIdAndUuid.java
rename to ebean-test/src/test/java/org/tests/insert/TestInsertWithIdAndUuid.java
index d2777fc3b..e2c1b9ebc 100644
--- a/ebean-core/src/test/java/org/tests/insert/TestInsertWithIdAndUuid.java
+++ b/ebean-test/src/test/java/org/tests/insert/TestInsertWithIdAndUuid.java
@@ -2,7 +2,7 @@ package org.tests.insert;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/insert/TestOnlyIdEntity.java b/ebean-test/src/test/java/org/tests/insert/TestOnlyIdEntity.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/insert/TestOnlyIdEntity.java
rename to ebean-test/src/test/java/org/tests/insert/TestOnlyIdEntity.java
index cb576612c..b33391c5b 100644
--- a/ebean-core/src/test/java/org/tests/insert/TestOnlyIdEntity.java
+++ b/ebean-test/src/test/java/org/tests/insert/TestOnlyIdEntity.java
@@ -5,8 +5,8 @@ import io.ebean.DB;
 import io.ebean.Database;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -20,11 +20,11 @@ public class TestOnlyIdEntity extends BaseTestCase {
 
     final Database database = DB.getDefault();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     OnlyIdEntity bean = new OnlyIdEntity();
     database.save(bean);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(bean.getId()).isGreaterThan(0);
     assertThat(sql).hasSize(1);
diff --git a/ebean-core/src/test/java/org/tests/insert/TestSaveWithDaylightSavings.java b/ebean-test/src/test/java/org/tests/insert/TestSaveWithDaylightSavings.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/insert/TestSaveWithDaylightSavings.java
rename to ebean-test/src/test/java/org/tests/insert/TestSaveWithDaylightSavings.java
index 20d320a80..6407aa046 100644
--- a/ebean-core/src/test/java/org/tests/insert/TestSaveWithDaylightSavings.java
+++ b/ebean-test/src/test/java/org/tests/insert/TestSaveWithDaylightSavings.java
@@ -1,7 +1,7 @@
 package org.tests.insert;
 
 import io.ebean.BaseTestCase;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.SQLException;
 
@@ -29,11 +29,11 @@ public class TestSaveWithDaylightSavings extends BaseTestCase {
 //      EBasic e = new EBasic();
 //      e.setSomeDate(daylightSavingDate);
 //
-//      Ebean.save(e);
+//      DB.save(e);
 //      Assert.assertNotNull(e.getId());
 //
 //      // Reload the entity from database
-//      EBasic e2 = Ebean.find(EBasic.class, e.getId());
+//      EBasic e2 = DB.find(EBasic.class, e.getId());
 //
 //      long diffMillis = e2.getSomeDate().getTime() - e.getSomeDate().getTime();
 //
@@ -58,7 +58,7 @@ public class TestSaveWithDaylightSavings extends BaseTestCase {
 //    // For it to fail, the time has to match the time at which the daylight saving changes
 //    // are applied in that time zone. Therefore specify it explicitly.
 //
-//    EbeanServer server = Ebean.getServer(null);
+//    Database server = DB.getDefault();
 //
 //    Transaction transaction = server.createTransaction();
 //    Connection connection = transaction.getConnection();
diff --git a/ebean-core/src/test/java/org/tests/iud/PcfCalendar.java b/ebean-test/src/test/java/org/tests/iud/PcfCalendar.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/iud/PcfCalendar.java
rename to ebean-test/src/test/java/org/tests/iud/PcfCalendar.java
diff --git a/ebean-core/src/test/java/org/tests/iud/PcfCity.java b/ebean-test/src/test/java/org/tests/iud/PcfCity.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/iud/PcfCity.java
rename to ebean-test/src/test/java/org/tests/iud/PcfCity.java
diff --git a/ebean-core/src/test/java/org/tests/iud/PcfCountry.java b/ebean-test/src/test/java/org/tests/iud/PcfCountry.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/iud/PcfCountry.java
rename to ebean-test/src/test/java/org/tests/iud/PcfCountry.java
diff --git a/ebean-core/src/test/java/org/tests/iud/PcfEvent.java b/ebean-test/src/test/java/org/tests/iud/PcfEvent.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/iud/PcfEvent.java
rename to ebean-test/src/test/java/org/tests/iud/PcfEvent.java
diff --git a/ebean-core/src/test/java/org/tests/iud/PcfModel.java b/ebean-test/src/test/java/org/tests/iud/PcfModel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/iud/PcfModel.java
rename to ebean-test/src/test/java/org/tests/iud/PcfModel.java
diff --git a/ebean-core/src/test/java/org/tests/iud/PcfPerson.java b/ebean-test/src/test/java/org/tests/iud/PcfPerson.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/iud/PcfPerson.java
rename to ebean-test/src/test/java/org/tests/iud/PcfPerson.java
diff --git a/ebean-core/src/test/java/org/tests/iud/TestCarWheelIud.java b/ebean-test/src/test/java/org/tests/iud/TestCarWheelIud.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/iud/TestCarWheelIud.java
rename to ebean-test/src/test/java/org/tests/iud/TestCarWheelIud.java
index 7d2be0607..4b57bede3 100644
--- a/ebean-core/src/test/java/org/tests/iud/TestCarWheelIud.java
+++ b/ebean-test/src/test/java/org/tests/iud/TestCarWheelIud.java
@@ -2,10 +2,9 @@ package org.tests.iud;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.PagedList;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.carwheel.Car;
 import org.tests.model.carwheel.Tire;
 import org.tests.model.carwheel.Wheel;
@@ -51,12 +50,12 @@ public class TestCarWheelIud extends BaseTestCase {
 
     car.setWheels(wheels);
 
-    Ebean.save(car);
+    DB.save(car);
 
     // And I'm trying to delete this entry with code:
-    Car car2 = Ebean.find(Car.class, car.getId());
+    Car car2 = DB.find(Car.class, car.getId());
 
-    Ebean.delete(car2);
+    DB.delete(car2);
 
   }
 
@@ -71,7 +70,7 @@ public class TestCarWheelIud extends BaseTestCase {
 
     DB.saveAll(asList(car0, car1, car2));
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     final PagedList<Car> pagedList = DB.find(Car.class)
       .select("brand, totalSold")
@@ -84,7 +83,7 @@ public class TestCarWheelIud extends BaseTestCase {
     assertThat(list).hasSize(2);
     assertThat(count).isEqualTo(2);
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     if (isH2() || isPostgres()) {
       assertSql(sql.get(0)).contains("select t0.brand, sum(t0.sold) from sa_car t0 group by t0.brand limit 10");
diff --git a/ebean-core/src/test/java/org/tests/iud/TestInfoOneToOne.java b/ebean-test/src/test/java/org/tests/iud/TestInfoOneToOne.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/iud/TestInfoOneToOne.java
rename to ebean-test/src/test/java/org/tests/iud/TestInfoOneToOne.java
index 9fad6d8ec..b86cc5e5c 100644
--- a/ebean-core/src/test/java/org/tests/iud/TestInfoOneToOne.java
+++ b/ebean-test/src/test/java/org/tests/iud/TestInfoOneToOne.java
@@ -1,14 +1,14 @@
 package org.tests.iud;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.info.InfoCompany;
 import org.tests.model.info.InfoCustomer;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestInfoOneToOne extends BaseTestCase {
 
@@ -25,7 +25,7 @@ public class TestInfoOneToOne extends BaseTestCase {
     customer.save();
 
     // assert JsonIgnore working as expected
-    String asJson = Ebean.json().toJson(company);
+    String asJson = DB.json().toJson(company);
     assertThat(asJson).doesNotContain("contacts");
 
     // assert both are inserted
diff --git a/ebean-core/src/test/java/org/tests/iud/TestInsertQueryUpdate.java b/ebean-test/src/test/java/org/tests/iud/TestInsertQueryUpdate.java
similarity index 55%
rename from ebean-core/src/test/java/org/tests/iud/TestInsertQueryUpdate.java
rename to ebean-test/src/test/java/org/tests/iud/TestInsertQueryUpdate.java
index d191bff8c..3741a2d55 100644
--- a/ebean-core/src/test/java/org/tests/iud/TestInsertQueryUpdate.java
+++ b/ebean-test/src/test/java/org/tests/iud/TestInsertQueryUpdate.java
@@ -2,13 +2,14 @@ package org.tests.iud;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.Set;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
 public class TestInsertQueryUpdate extends BaseTestCase {
 
   @Test
@@ -16,23 +17,23 @@ public class TestInsertQueryUpdate extends BaseTestCase {
 
     EBasicVer e0 = new EBasicVer("name0");
     e0.setDescription("desc0");
-    Ebean.save(e0);
+    DB.save(e0);
 
-    EBasicVer e1 = Ebean.find(EBasicVer.class)
+    EBasicVer e1 = DB.find(EBasicVer.class)
       .select("name")
       .setId(e0.getId())
       .findOne();
 
-    BeanState beanState = Ebean.getBeanState(e1);
-    Set<String> loadedProps = beanState.getLoadedProps();
-    Assert.assertFalse(loadedProps.contains("description"));
+    BeanState beanState = DB.beanState(e1);
+    Set<String> loadedProps = beanState.loadedProps();
+    assertFalse(loadedProps.contains("description"));
     //lastUpdate
 
     e1.setName("name1");
-    Ebean.save(e1);
+    DB.save(e1);
 
     e1.setDescription("desc1");
-    Ebean.save(e1);
+    DB.save(e1);
 
   }
 
diff --git a/ebean-test/src/test/java/org/tests/iud/TestInsertUpdateTrans.java b/ebean-test/src/test/java/org/tests/iud/TestInsertUpdateTrans.java
new file mode 100644
index 000000000..48e72585b
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/iud/TestInsertUpdateTrans.java
@@ -0,0 +1,42 @@
+package org.tests.iud;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.Transaction;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.EBasicVer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class TestInsertUpdateTrans extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    try (Transaction txn = DB.beginTransaction()) {
+
+      EBasicVer e0 = new EBasicVer("onInsert");
+      e0.setDescription("something");
+      DB.save(e0);
+
+      assertNotNull(e0.getId());
+      assertNotNull(e0.getLastUpdate());
+      assertEquals("onInsert", e0.getName());
+
+      e0.setName("onUpdate");
+      e0.setDescription("differentFromInsert");
+
+      DB.save(e0);
+
+      EBasicVer e1 = DB.find(EBasicVer.class, e0.getId());
+
+      // we should fetch back the updated data (not inserted)
+      assertEquals(e0.getId(), e1.getId());
+      assertEquals("onUpdate", e1.getName());
+      assertEquals("differentFromInsert", e1.getDescription());
+
+      txn.commit();
+    }
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/iud/TestPersistCascade.java b/ebean-test/src/test/java/org/tests/iud/TestPersistCascade.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/iud/TestPersistCascade.java
rename to ebean-test/src/test/java/org/tests/iud/TestPersistCascade.java
index e523ddf83..6aeaa4a37 100644
--- a/ebean-core/src/test/java/org/tests/iud/TestPersistCascade.java
+++ b/ebean-test/src/test/java/org/tests/iud/TestPersistCascade.java
@@ -2,8 +2,8 @@ package org.tests.iud;
 
 import io.avaje.moduuid.ModUUID;
 import io.ebean.BaseTestCase;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -21,10 +21,10 @@ public class TestPersistCascade extends BaseTestCase {
       country.addCity(new PcfCity("city_" + ModUUID.newShortId(), mayor, viceMayor));
     }
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     country.save();
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
 
     if (isPersistBatchOnCascade()) {
       assertSql(sql.get(0)).contains("insert into pcf_country");
diff --git a/ebean-core/src/test/java/org/tests/json/TestDbJson_Jackson.java b/ebean-test/src/test/java/org/tests/json/TestDbJson_Jackson.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/json/TestDbJson_Jackson.java
rename to ebean-test/src/test/java/org/tests/json/TestDbJson_Jackson.java
index 00b4bfa52..25302f8e1 100644
--- a/ebean-core/src/test/java/org/tests/json/TestDbJson_Jackson.java
+++ b/ebean-test/src/test/java/org/tests/json/TestDbJson_Jackson.java
@@ -2,8 +2,8 @@ package org.tests.json;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicJsonJackson;
 import org.tests.model.json.EBasicJsonJackson2;
 import org.tests.model.json.LongJacksonType;
@@ -37,7 +37,7 @@ public class TestDbJson_Jackson extends BaseTestCase {
     bean.getValueMap().put(1, "one");
     bean.getValueMap().put(2, "two");
 
-    ObjectMapper mapper = (ObjectMapper) Ebean.getDefaultServer().getPluginApi().getServerConfig().getObjectMapper();
+    ObjectMapper mapper = (ObjectMapper) DB.getDefault().pluginApi().config().getObjectMapper();
 
     String json = mapper.writeValueAsString(bean);
     EBasicJsonJackson found = mapper.readValue(json, EBasicJsonJackson.class);
@@ -48,10 +48,10 @@ public class TestDbJson_Jackson extends BaseTestCase {
     assertThat(found.getValueSet()).containsExactly("A", "B");
     assertThat(found.getValueMap()).containsEntry(1L, "one").containsEntry(2L, "two");
 
-    Ebean.save(bean);
+    DB.save(bean);
 
     // here we do the same and expect, that we can deserialize the bean also
-    found = Ebean.find(EBasicJsonJackson.class, bean.getId());
+    found = DB.find(EBasicJsonJackson.class, bean.getId());
 
     assertThat(found.getPlainValue()).isEqualTo("plain");
     assertThat(found.getValueList()).containsExactly("A", "B");
@@ -83,7 +83,7 @@ public class TestDbJson_Jackson extends BaseTestCase {
     bean.getValueMap().put(1, new StringJacksonType("A"));
     bean.getValueMap().put(2, new LongJacksonType(7l));
 
-    ObjectMapper mapper = (ObjectMapper) Ebean.getDefaultServer().getPluginApi().getServerConfig().getObjectMapper();
+    ObjectMapper mapper = (ObjectMapper) DB.getDefault().pluginApi().config().getObjectMapper();
 
     String json = mapper.writeValueAsString(bean);
     assertThat(json)
@@ -96,9 +96,9 @@ public class TestDbJson_Jackson extends BaseTestCase {
     assertThat(found.getValueSet()).hasSize(2);
     assertThat(found.getValueMap()).hasSize(2);;
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    found = Ebean.find(EBasicJsonJackson2.class, bean.getId());
+    found = DB.find(EBasicJsonJackson2.class, bean.getId());
 
     assertThat(found.getPlainValue()).isInstanceOf(LongJacksonType.class);
     assertThat(found.getValueList()).hasSize(2);
diff --git a/ebean-core/src/test/java/org/tests/json/TestDbJson_Jackson2.java b/ebean-test/src/test/java/org/tests/json/TestDbJson_Jackson2.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/json/TestDbJson_Jackson2.java
rename to ebean-test/src/test/java/org/tests/json/TestDbJson_Jackson2.java
index f4a9a0d41..52a176dd3 100644
--- a/ebean-core/src/test/java/org/tests/json/TestDbJson_Jackson2.java
+++ b/ebean-test/src/test/java/org/tests/json/TestDbJson_Jackson2.java
@@ -2,8 +2,8 @@ package org.tests.json;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicJsonJackson2;
 import org.tests.model.json.LongJacksonType;
 import org.tests.model.json.StringJacksonType;
@@ -34,7 +34,7 @@ public class TestDbJson_Jackson2 extends BaseTestCase {
     bean.getValueMap().put(1, new StringJacksonType("A"));
     bean.getValueMap().put(2, new LongJacksonType(7l));
 
-    ObjectMapper mapper = (ObjectMapper) Ebean.getDefaultServer().getPluginApi().getServerConfig().getObjectMapper();
+    ObjectMapper mapper = (ObjectMapper) DB.getDefault().pluginApi().config().getObjectMapper();
 
     String json = mapper.writeValueAsString(bean);
     found = mapper.readValue(json, EBasicJsonJackson2.class);
@@ -44,9 +44,9 @@ public class TestDbJson_Jackson2 extends BaseTestCase {
     assertThat(found.getValueSet()).hasSize(2);
     assertThat(found.getValueMap()).hasSize(2);;
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    found = Ebean.find(EBasicJsonJackson2.class, bean.getId());
+    found = DB.find(EBasicJsonJackson2.class, bean.getId());
 
     assertThat(found.getPlainValue()).isInstanceOf(LongJacksonType.class);
     assertThat(found.getValueList()).hasSize(2);
diff --git a/ebean-core/src/test/java/org/tests/json/TestDbJson_Jackson3.java b/ebean-test/src/test/java/org/tests/json/TestDbJson_Jackson3.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/json/TestDbJson_Jackson3.java
rename to ebean-test/src/test/java/org/tests/json/TestDbJson_Jackson3.java
index 5b58b3108..ff9c3216c 100644
--- a/ebean-core/src/test/java/org/tests/json/TestDbJson_Jackson3.java
+++ b/ebean-test/src/test/java/org/tests/json/TestDbJson_Jackson3.java
@@ -4,15 +4,13 @@ import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
 import io.ebean.DB;
 import io.ebean.ValuePair;
+import io.ebean.annotation.IgnorePlatform;
+import io.ebean.annotation.Platform;
 import io.ebean.event.BeanPersistAdapter;
 import io.ebean.event.BeanPersistRequest;
-import io.ebeantest.LoggedSql;
-import org.junit.Test;
-import org.tests.model.json.EBasicJsonJackson3;
-import org.tests.model.json.EBasicJsonList;
-import org.tests.model.json.EBasicJsonMulti;
-import org.tests.model.json.PlainBean;
-import org.tests.model.json.PlainBeanDirtyAware;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
+import org.tests.model.json.*;
 
 import java.util.Arrays;
 import java.util.List;
@@ -33,19 +31,20 @@ public class TestDbJson_Jackson3 extends BaseTestCase {
 
     @Override
     public boolean preInsert(BeanPersistRequest<?> request) {
-      updatedValues = request.getUpdatedValues();
+      updatedValues = request.updatedValues();
       return true;
     }
 
     @Override
     public boolean preUpdate(BeanPersistRequest<?> request) {
-      updatedValues = request.getUpdatedValues();
+      updatedValues = request.updatedValues();
       return true;
     }
   }
+
+  @IgnorePlatform(Platform.MYSQL)
   @Test
   public void updateIncludesJsonColumn_when_explicit_isMarkedDirty() {
-
     PlainBeanDirtyAware contentBean = new PlainBeanDirtyAware("a", 42);
 
     EBasicJsonJackson3 bean = new EBasicJsonJackson3();
@@ -76,9 +75,9 @@ public class TestDbJson_Jackson3 extends BaseTestCase {
     assertThat(found2.getPlainValue().getName()).isEqualTo("b");
   }
 
+  @IgnorePlatform(Platform.MYSQL)
   @Test
   public void updateIncludesJsonColumn_when_loadedAndNotDirtyAware() {
-
     PlainBean contentBean = new PlainBean("a", 42);
     EBasicJsonList bean = new EBasicJsonList();
     bean.setName("p1");
@@ -92,19 +91,18 @@ public class TestDbJson_Jackson3 extends BaseTestCase {
     found.setName("p1-mod");
     found.setBeanList(null);
 
-    BeanState state = DB.getBeanState(found);
-    assertThat(state.getChangedProps()).containsExactlyInAnyOrder("name", "beanList");
+    BeanState state = DB.beanState(found);
+    assertThat(state.changedProps()).containsExactlyInAnyOrder("name", "beanList");
 
-    ValuePair pair = state.getDirtyValues().get("name");
+    ValuePair pair = state.dirtyValues().get("name");
     assertThat(pair.getNewValue()).isEqualTo("p1-mod");
     assertThat(pair.getOldValue()).isEqualTo("p1");
 
-    pair = state.getDirtyValues().get("beanList");
+    pair = state.dirtyValues().get("beanList");
     assertThat(pair.getNewValue()).isEqualTo(null);
-    assertThat((List<PlainBean>)pair.getOldValue()).hasSize(1)
+    assertThat((List<PlainBean>) pair.getOldValue()).hasSize(1)
       .extracting(PlainBean::getName).containsExactly("a");
 
-
     LoggedSql.start();
     DB.save(found);
 
@@ -113,16 +111,16 @@ public class TestDbJson_Jackson3 extends BaseTestCase {
 
     assertThat(EBasicJsonListPersistController.updatedValues.entrySet())
       .extracting(Map.Entry::toString)
-      .containsExactlyInAnyOrder("beanList=null,[name:a]","name=p1-mod,p1","version=2,1");
+      .containsExactlyInAnyOrder("beanList=null,[name:a]", "name=p1-mod,p1", "version=2,1");
 
-    assertThat(DB.getBeanState(found).isDirty()).isFalse();
+    assertThat(DB.beanState(found).isDirty()).isFalse();
 
     found.getPlainBean().setName("b");
-    assertThat(DB.getBeanState(found).isDirty()).isTrue();
+    assertThat(DB.beanState(found).isDirty()).isTrue();
 
-    state = DB.getBeanState(found);
-    assertThat(state.getChangedProps()).containsExactlyInAnyOrder("plainBean");
-    pair = state.getDirtyValues().get("plainBean");
+    state = DB.beanState(found);
+    assertThat(state.changedProps()).containsExactlyInAnyOrder("plainBean");
+    pair = state.dirtyValues().get("plainBean");
     assertThat(pair.getNewValue()).hasToString("name:b");
     assertThat(pair.getOldValue()).hasToString("name:a");
 
@@ -140,9 +138,9 @@ public class TestDbJson_Jackson3 extends BaseTestCase {
     LoggedSql.stop();
   }
 
+  @IgnorePlatform(Platform.MYSQL)
   @Test
   public void updateIncludesJsonColumn_when_list_loadedAndNotDirtyAware() {
-
     PlainBean contentBean = new PlainBean("a", 42);
     EBasicJsonList bean = new EBasicJsonList();
     bean.setName("p1");
@@ -153,10 +151,11 @@ public class TestDbJson_Jackson3 extends BaseTestCase {
     final EBasicJsonList found = DB.find(EBasicJsonList.class, bean.getId());
     found.getBeanList().get(0).setName("p1-mod");
 
-    BeanState state = DB.getBeanState(found);
-    assertThat(state.getChangedProps()).containsExactlyInAnyOrder("beanList");
+    BeanState state = DB.beanState(found);
+    assertThat(state.changedProps()).containsExactlyInAnyOrder("beanList");
   }
 
+  @IgnorePlatform(Platform.MYSQL)
   @Test
   public void update_with_differentDbJsonSettings() {
     PlainBeanDirtyAware contentBean1 = new PlainBeanDirtyAware("x", 42);
@@ -169,32 +168,32 @@ public class TestDbJson_Jackson3 extends BaseTestCase {
     bean.setPlainValue2(contentBean2);
     bean.setPlainValue3(contentBean3);
 
-    BeanState state = DB.getBeanState(bean);
+    BeanState state = DB.beanState(bean);
     // a new bean is not considered as dirty (thus have no changed props)
     assertThat(state.isDirty()).isFalse();
     assertThat(state.isNewOrDirty()).isTrue();
-    assertThat(state.getChangedProps()).isEmpty();
+    assertThat(state.changedProps()).isEmpty();
 
     bean.save();
 
     bean = DB.find(EBasicJsonJackson3.class, bean.getId());
-    state = DB.getBeanState(bean);
+    state = DB.beanState(bean);
     // a fresh loaded bean is also not considered as dirty
     assertThat(state.isDirty()).isFalse();
     assertThat(state.isNewOrDirty()).isFalse();
-    assertThat(state.getChangedProps()).isEmpty();
+    assertThat(state.changedProps()).isEmpty();
 
     bean.getPlainValue().setName("a"); // has SOURCE
 
     assertThat(state.isDirty()).isTrue();
-    assertThat(state.getChangedProps()).containsExactly("plainValue");
+    assertThat(state.changedProps()).containsExactly("plainValue");
 
     bean.getPlainValue2().setName("b");
-    assertThat(state.getChangedProps()).containsExactlyInAnyOrder("plainValue", "plainValue2");
+    assertThat(state.changedProps()).containsExactlyInAnyOrder("plainValue", "plainValue2");
 
     bean.getPlainValue3().setName("c"); // has mutationDetection = NONE
 
-    Map<String, ValuePair> dirtyValues = state.getDirtyValues();
+    Map<String, ValuePair> dirtyValues = state.dirtyValues();
     assertThat(dirtyValues).hasSize(2).containsKeys("plainValue", "plainValue2");
 
     assertThat(dirtyValues.get("plainValue")).hasToString("name:a,name:x"); // SOURCE -> origValue present
@@ -222,20 +221,19 @@ public class TestDbJson_Jackson3 extends BaseTestCase {
 
     LoggedSql.stop();
   }
-  
+
   @Test
   public void push_pop_test() {
-    
     EBasicJsonMulti bean = new EBasicJsonMulti();
     bean.setPlainValue2(new PlainBeanDirtyAware("x", 42));
     bean.save();
-    
+
     bean = DB.find(EBasicJsonMulti.class, bean.getId());
     bean.setPlainValue1(null); // already null
     bean.setPlainValue2(null);
     bean.setPlainValue3(null); // already null
-    BeanState state = DB.getBeanState(bean);
-    assertThat(state.getDirtyValues()).hasSize(1).containsKey("plainValue2");
+    BeanState state = DB.beanState(bean);
+    assertThat(state.dirtyValues()).hasSize(1).containsKey("plainValue2");
   }
 
   private void expectedSql(int i, String s) {
diff --git a/ebean-core/src/test/java/org/tests/json/TestDbJson_List.java b/ebean-test/src/test/java/org/tests/json/TestDbJson_List.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/json/TestDbJson_List.java
rename to ebean-test/src/test/java/org/tests/json/TestDbJson_List.java
index e20beb1d8..ce84f08b3 100644
--- a/ebean-core/src/test/java/org/tests/json/TestDbJson_List.java
+++ b/ebean-test/src/test/java/org/tests/json/TestDbJson_List.java
@@ -4,24 +4,17 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
+import io.ebean.test.LoggedSql;
 import io.ebean.text.TextException;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicJsonList;
 import org.tests.model.json.PlainBean;
 
 import javax.persistence.PersistenceException;
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestDbJson_List extends BaseTestCase {
 
@@ -31,12 +24,9 @@ public class TestDbJson_List extends BaseTestCase {
 
   @Test
   public void insert() {
-
     bean.setName("stuff");
-
     bean.getTags().add("one");
     bean.getTags().add("two");
-
     bean.getFlags().add(42L);
     bean.getFlags().add(43L);
     bean.getFlags().add(44L);
@@ -108,13 +98,15 @@ public class TestDbJson_List extends BaseTestCase {
   private void update_when_notDirty() {
 
     found.setName("mod");
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.save(found);
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     // we don't update the phone numbers (as they are not dirty)
     // plain_bean=?, no longer included with dirty detection
-    assertSql(sql.get(0)).contains("update ebasic_json_list set name=?, version=? where");
+    if (!isMySql()) {
+      assertSql(sql.get(0)).contains("update ebasic_json_list set name=?, version=? where");
+    }
   }
 
   private void update_when_dirty() {
@@ -122,9 +114,9 @@ public class TestDbJson_List extends BaseTestCase {
     //found.setName("modAgain");
     found.getTags().add("three");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.save(found);
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     // we don't update the phone numbers (as they are not dirty)
     // plain_bean=? not included using MD5 dirty detection
@@ -136,9 +128,9 @@ public class TestDbJson_List extends BaseTestCase {
     //found.setName("modAgain");
     found.getFlags().remove(42L);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.save(found);
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     // we don't update the phone numbers (as they are not dirty)
     // plain_bean=? not included with MD5 dirty detection
@@ -152,9 +144,9 @@ public class TestDbJson_List extends BaseTestCase {
     found.getBeanList().clear();
     found.getBeanMap().remove("key0");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.save(found);
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     // we don't update the phone numbers (as they are not dirty)
     // plain_bean=? not included with MD5 dirty detection
@@ -203,8 +195,7 @@ public class TestDbJson_List extends BaseTestCase {
         .setId(bean.getId())
         .findOne();
 
-      // never get here
-      assertTrue(false);
+      fail("never get here");
 
     } catch (PersistenceException e) {
       // query fails due to error loading invalid JSON content
@@ -216,7 +207,7 @@ public class TestDbJson_List extends BaseTestCase {
       .setAllowLoadErrors() // allow invalid JSON content
       .findOne();
 
-    Map<String, Exception> errors = server().getBeanState(bean).getLoadErrors();
+    Map<String, Exception> errors = server().beanState(bean).loadErrors();
 
     assertThat(errors).containsKey("beanMap").hasSize(1);
     assertThat(errors.values().iterator().next())
diff --git a/ebean-core/src/test/java/org/tests/json/TestJsonMapBasic.java b/ebean-test/src/test/java/org/tests/json/TestJsonMapBasic.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/json/TestJsonMapBasic.java
rename to ebean-test/src/test/java/org/tests/json/TestJsonMapBasic.java
index 01d105760..e186de792 100644
--- a/ebean-core/src/test/java/org/tests/json/TestJsonMapBasic.java
+++ b/ebean-test/src/test/java/org/tests/json/TestJsonMapBasic.java
@@ -3,10 +3,10 @@ package org.tests.json;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
+import io.ebean.test.LoggedSql;
 import io.ebean.text.json.EJson;
-import io.ebeantest.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicJsonMap;
-import org.junit.Test;
 import org.tests.model.json.EBasicJsonMapDetail;
 
 import java.io.IOException;
@@ -14,7 +14,7 @@ import java.util.List;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonMapBasic extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/json/TestJsonMapBlob.java b/ebean-test/src/test/java/org/tests/json/TestJsonMapBlob.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/json/TestJsonMapBlob.java
rename to ebean-test/src/test/java/org/tests/json/TestJsonMapBlob.java
index 25091d91c..d73f27625 100644
--- a/ebean-core/src/test/java/org/tests/json/TestJsonMapBlob.java
+++ b/ebean-test/src/test/java/org/tests/json/TestJsonMapBlob.java
@@ -1,15 +1,15 @@
 package org.tests.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.EJson;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicJsonMapBlob;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonMapBlob extends BaseTestCase {
 
@@ -24,9 +24,9 @@ public class TestJsonMapBlob extends BaseTestCase {
     bean.setName("one");
     bean.setContent(content);
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonMapBlob bean1 = Ebean.find(EBasicJsonMapBlob.class, bean.getId());
+    EBasicJsonMapBlob bean1 = DB.find(EBasicJsonMapBlob.class, bean.getId());
 
     assertEquals(bean.getId(), bean1.getId());
     assertEquals(bean.getName(), bean1.getName());
@@ -34,6 +34,6 @@ public class TestJsonMapBlob extends BaseTestCase {
     assertEquals(18L, bean1.getContent().get("docId"));
 
     bean1.setName("just change name");
-    Ebean.save(bean1);
+    DB.save(bean1);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/json/TestJsonMapClob.java b/ebean-test/src/test/java/org/tests/json/TestJsonMapClob.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/json/TestJsonMapClob.java
rename to ebean-test/src/test/java/org/tests/json/TestJsonMapClob.java
index ecf21b7fe..c87ad37f4 100644
--- a/ebean-core/src/test/java/org/tests/json/TestJsonMapClob.java
+++ b/ebean-test/src/test/java/org/tests/json/TestJsonMapClob.java
@@ -1,15 +1,15 @@
 package org.tests.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.EJson;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicJsonMapClob;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonMapClob extends BaseTestCase {
 
@@ -24,9 +24,9 @@ public class TestJsonMapClob extends BaseTestCase {
     bean.setName("one");
     bean.setContent(content);
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonMapClob bean1 = Ebean.find(EBasicJsonMapClob.class, bean.getId());
+    EBasicJsonMapClob bean1 = DB.find(EBasicJsonMapClob.class, bean.getId());
 
     assertEquals(bean.getId(), bean1.getId());
     assertEquals(bean.getName(), bean1.getName());
@@ -34,6 +34,6 @@ public class TestJsonMapClob extends BaseTestCase {
     assertEquals(18L, bean1.getContent().get("docId"));
 
     bean1.setName("just change name");
-    Ebean.save(bean1);
+    DB.save(bean1);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/json/TestJsonMapJsonB.java b/ebean-test/src/test/java/org/tests/json/TestJsonMapJsonB.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/json/TestJsonMapJsonB.java
rename to ebean-test/src/test/java/org/tests/json/TestJsonMapJsonB.java
index d33efe02f..66e28b5f9 100644
--- a/ebean-core/src/test/java/org/tests/json/TestJsonMapJsonB.java
+++ b/ebean-test/src/test/java/org/tests/json/TestJsonMapJsonB.java
@@ -1,15 +1,15 @@
 package org.tests.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.EJson;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicJsonMapJsonB;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonMapJsonB extends BaseTestCase {
 
@@ -24,9 +24,9 @@ public class TestJsonMapJsonB extends BaseTestCase {
     bean.setName("one");
     bean.setContent(content);
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonMapJsonB bean1 = Ebean.find(EBasicJsonMapJsonB.class, bean.getId());
+    EBasicJsonMapJsonB bean1 = DB.find(EBasicJsonMapJsonB.class, bean.getId());
 
     assertEquals(bean.getId(), bean1.getId());
     assertEquals(bean.getName(), bean1.getName());
@@ -34,6 +34,6 @@ public class TestJsonMapJsonB extends BaseTestCase {
     assertEquals(18L, bean1.getContent().get("docId"));
 
     bean1.setName("just change name");
-    Ebean.save(bean1);
+    DB.save(bean1);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/json/TestJsonMapVarchar.java b/ebean-test/src/test/java/org/tests/json/TestJsonMapVarchar.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/json/TestJsonMapVarchar.java
rename to ebean-test/src/test/java/org/tests/json/TestJsonMapVarchar.java
index 96b775ef3..551040e72 100644
--- a/ebean-core/src/test/java/org/tests/json/TestJsonMapVarchar.java
+++ b/ebean-test/src/test/java/org/tests/json/TestJsonMapVarchar.java
@@ -1,15 +1,15 @@
 package org.tests.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.EJson;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicJsonMapVarchar;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonMapVarchar extends BaseTestCase {
 
@@ -24,9 +24,9 @@ public class TestJsonMapVarchar extends BaseTestCase {
     bean.setName("one");
     bean.setContent(content);
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonMapVarchar bean1 = Ebean.find(EBasicJsonMapVarchar.class, bean.getId());
+    EBasicJsonMapVarchar bean1 = DB.find(EBasicJsonMapVarchar.class, bean.getId());
 
     assertEquals(bean.getId(), bean1.getId());
     assertEquals(bean.getName(), bean1.getName());
@@ -34,6 +34,6 @@ public class TestJsonMapVarchar extends BaseTestCase {
     assertEquals(18L, bean1.getContent().get("docId"));
 
     bean1.setName("just change name");
-    Ebean.save(bean1);
+    DB.save(bean1);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/json/TestJsonNodeBasic.java b/ebean-test/src/test/java/org/tests/json/TestJsonNodeBasic.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/json/TestJsonNodeBasic.java
rename to ebean-test/src/test/java/org/tests/json/TestJsonNodeBasic.java
index 9141b171e..77bdfbb1c 100644
--- a/ebean-core/src/test/java/org/tests/json/TestJsonNodeBasic.java
+++ b/ebean-test/src/test/java/org/tests/json/TestJsonNodeBasic.java
@@ -3,24 +3,21 @@ package org.tests.json;
 import com.fasterxml.jackson.core.JsonFactory;
 import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.tests.model.basic.Order;
-import org.tests.model.json.EBasicJsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Test;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Order;
+import org.tests.model.json.EBasicJsonNode;
 
 import java.io.IOException;
 import java.io.StringWriter;
 import java.util.Set;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestJsonNodeBasic extends BaseTestCase {
 
@@ -38,9 +35,9 @@ public class TestJsonNodeBasic extends BaseTestCase {
     bean.setName("one");
     bean.setContent(content);
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonNode bean1 = Ebean.find(EBasicJsonNode.class, bean.getId());
+    EBasicJsonNode bean1 = DB.find(EBasicJsonNode.class, bean.getId());
 
     assertEquals(bean.getId(), bean1.getId());
     assertEquals(bean.getName(), bean1.getName());
@@ -49,15 +46,15 @@ public class TestJsonNodeBasic extends BaseTestCase {
     assertEquals(18L, bean1.getContent().get("docId").asLong());
 
     bean1.setName("just change name");
-    Ebean.save(bean1);
+    DB.save(bean1);
 
     JsonNode content1 = objectMapper.readTree(s1);
 
     bean1.setName("two");
     bean1.setContent(content1);
-    Ebean.save(bean1);
+    DB.save(bean1);
 
-    EBasicJsonNode bean2 = Ebean.find(EBasicJsonNode.class, bean.getId());
+    EBasicJsonNode bean2 = DB.find(EBasicJsonNode.class, bean.getId());
 
     // name changed and docId changed
     assertEquals("two", bean2.getName());
@@ -66,18 +63,18 @@ public class TestJsonNodeBasic extends BaseTestCase {
     // content persisted even though it has not changed (as it's loaded)
     // we can't do dirty detection on JsonNode (like we do on Map<String,Object>)
     bean1.setName("three");
-    Ebean.save(bean1);
+    DB.save(bean1);
 
-    EBasicJsonNode bean3 = Ebean.find(EBasicJsonNode.class, bean.getId());
+    EBasicJsonNode bean3 = DB.find(EBasicJsonNode.class, bean.getId());
 
     assertEquals("three", bean3.getName());
     assertEquals(99L, bean3.getContent().path("docId").asLong());
 
     // write whole bean with content as JSON
-    String fullBeanJson = Ebean.json().toJson(bean3);
+    String fullBeanJson = DB.json().toJson(bean3);
 
     // parse JSON into whole bean with content
-    EBasicJsonNode beanJsonRestored = Ebean.json().toBean(EBasicJsonNode.class, fullBeanJson);
+    EBasicJsonNode beanJsonRestored = DB.json().toBean(EBasicJsonNode.class, fullBeanJson);
 
     assertEquals(99L, beanJsonRestored.getContent().path("docId").asLong());
   }
@@ -94,20 +91,18 @@ public class TestJsonNodeBasic extends BaseTestCase {
     EBasicJsonNode bean = new EBasicJsonNode();
     bean.setName("lazyLoadTest");
     bean.setContent(content);
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonNode bean1 = Ebean.find(EBasicJsonNode.class)
+    EBasicJsonNode bean1 = DB.find(EBasicJsonNode.class)
       .select("name")
       .setId(bean.getId())
       .findOne();
 
-    Set<String> loadedProps = Ebean.getBeanState(bean1).getLoadedProps();
+    Set<String> loadedProps = DB.beanState(bean1).loadedProps();
     assertTrue(loadedProps.contains("name"));
     assertFalse(loadedProps.contains("content"));
 
-    JsonNode lazyLoadedContent = bean1.getContent();
-    assertNotNull(lazyLoadedContent);
-
+    assertNotNull(bean1.getContent());
   }
 
   @Test
diff --git a/ebean-core/src/test/java/org/tests/json/TestJsonNodeBlob.java b/ebean-test/src/test/java/org/tests/json/TestJsonNodeBlob.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/json/TestJsonNodeBlob.java
rename to ebean-test/src/test/java/org/tests/json/TestJsonNodeBlob.java
index ace17c972..0e349ff26 100644
--- a/ebean-core/src/test/java/org/tests/json/TestJsonNodeBlob.java
+++ b/ebean-test/src/test/java/org/tests/json/TestJsonNodeBlob.java
@@ -1,16 +1,16 @@
 package org.tests.json;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.tests.model.json.EBasicJsonNodeBlob;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Test;
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.json.EBasicJsonNodeBlob;
 
 import java.io.IOException;
 import java.util.Set;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestJsonNodeBlob extends BaseTestCase {
 
@@ -27,9 +27,9 @@ public class TestJsonNodeBlob extends BaseTestCase {
     bean.setName("one");
     bean.setContent(content);
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonNodeBlob bean1 = Ebean.find(EBasicJsonNodeBlob.class, bean.getId());
+    EBasicJsonNodeBlob bean1 = DB.find(EBasicJsonNodeBlob.class, bean.getId());
 
     assertEquals(bean.getId(), bean1.getId());
     assertEquals(bean.getName(), bean1.getName());
@@ -51,19 +51,17 @@ public class TestJsonNodeBlob extends BaseTestCase {
     EBasicJsonNodeBlob bean = new EBasicJsonNodeBlob();
     bean.setName("lazyLoadTest");
     bean.setContent(content);
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonNodeBlob bean1 = Ebean.find(EBasicJsonNodeBlob.class)
+    EBasicJsonNodeBlob bean1 = DB.find(EBasicJsonNodeBlob.class)
       .select("name")
       .setId(bean.getId())
       .findOne();
 
-    Set<String> loadedProps = Ebean.getBeanState(bean1).getLoadedProps();
+    Set<String> loadedProps = DB.beanState(bean1).loadedProps();
     assertTrue(loadedProps.contains("name"));
     assertFalse(loadedProps.contains("content"));
 
-    JsonNode lazyLoadedContent = bean1.getContent();
-    assertNotNull(lazyLoadedContent);
-
+    assertNotNull(bean1.getContent());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/json/TestJsonNodeJsonb.java b/ebean-test/src/test/java/org/tests/json/TestJsonNodeJsonb.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/json/TestJsonNodeJsonb.java
rename to ebean-test/src/test/java/org/tests/json/TestJsonNodeJsonb.java
index a50ce5d44..f863981f6 100644
--- a/ebean-core/src/test/java/org/tests/json/TestJsonNodeJsonb.java
+++ b/ebean-test/src/test/java/org/tests/json/TestJsonNodeJsonb.java
@@ -1,16 +1,16 @@
 package org.tests.json;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.tests.model.json.EBasicJsonNodeJsonB;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Test;
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.json.EBasicJsonNodeJsonB;
 
 import java.io.IOException;
 import java.util.Set;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestJsonNodeJsonb extends BaseTestCase {
 
@@ -27,9 +27,9 @@ public class TestJsonNodeJsonb extends BaseTestCase {
     bean.setName("one");
     bean.setContent(content);
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonNodeJsonB bean1 = Ebean.find(EBasicJsonNodeJsonB.class, bean.getId());
+    EBasicJsonNodeJsonB bean1 = DB.find(EBasicJsonNodeJsonB.class, bean.getId());
 
     assertEquals(bean.getId(), bean1.getId());
     assertEquals(bean.getName(), bean1.getName());
@@ -51,19 +51,17 @@ public class TestJsonNodeJsonb extends BaseTestCase {
     EBasicJsonNodeJsonB bean = new EBasicJsonNodeJsonB();
     bean.setName("lazyLoadTest");
     bean.setContent(content);
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonNodeJsonB bean1 = Ebean.find(EBasicJsonNodeJsonB.class)
+    EBasicJsonNodeJsonB bean1 = DB.find(EBasicJsonNodeJsonB.class)
       .select("name")
       .setId(bean.getId())
       .findOne();
 
-    Set<String> loadedProps = Ebean.getBeanState(bean1).getLoadedProps();
+    Set<String> loadedProps = DB.beanState(bean1).loadedProps();
     assertTrue(loadedProps.contains("name"));
     assertFalse(loadedProps.contains("content"));
 
-    JsonNode lazyLoadedContent = bean1.getContent();
-    assertNotNull(lazyLoadedContent);
-
+    assertNotNull(bean1.getContent());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/json/TestJsonNodeVarchar.java b/ebean-test/src/test/java/org/tests/json/TestJsonNodeVarchar.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/json/TestJsonNodeVarchar.java
rename to ebean-test/src/test/java/org/tests/json/TestJsonNodeVarchar.java
index eaa17ba62..c2de2026a 100644
--- a/ebean-core/src/test/java/org/tests/json/TestJsonNodeVarchar.java
+++ b/ebean-test/src/test/java/org/tests/json/TestJsonNodeVarchar.java
@@ -1,16 +1,16 @@
 package org.tests.json;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.tests.model.json.EBasicJsonNodeVarchar;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Test;
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.json.EBasicJsonNodeVarchar;
 
 import java.io.IOException;
 import java.util.Set;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestJsonNodeVarchar extends BaseTestCase {
 
@@ -27,16 +27,15 @@ public class TestJsonNodeVarchar extends BaseTestCase {
     bean.setName("one");
     bean.setContent(content);
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonNodeVarchar bean1 = Ebean.find(EBasicJsonNodeVarchar.class, bean.getId());
+    EBasicJsonNodeVarchar bean1 = DB.find(EBasicJsonNodeVarchar.class, bean.getId());
 
     assertEquals(bean.getId(), bean1.getId());
     assertEquals(bean.getName(), bean1.getName());
 
     assertEquals(bean.getContent().path("contentType").asText(), bean1.getContent().path("contentType").asText());
     assertEquals(18L, bean1.getContent().get("docId").asLong());
-
   }
 
   @Test
@@ -51,19 +50,17 @@ public class TestJsonNodeVarchar extends BaseTestCase {
     EBasicJsonNodeVarchar bean = new EBasicJsonNodeVarchar();
     bean.setName("lazyLoadTest");
     bean.setContent(content);
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicJsonNodeVarchar bean1 = Ebean.find(EBasicJsonNodeVarchar.class)
+    EBasicJsonNodeVarchar bean1 = DB.find(EBasicJsonNodeVarchar.class)
       .select("name")
       .setId(bean.getId())
       .findOne();
 
-    Set<String> loadedProps = Ebean.getBeanState(bean1).getLoadedProps();
+    Set<String> loadedProps = DB.beanState(bean1).loadedProps();
     assertTrue(loadedProps.contains("name"));
     assertFalse(loadedProps.contains("content"));
 
-    JsonNode lazyLoadedContent = bean1.getContent();
-    assertNotNull(lazyLoadedContent);
-
+    assertNotNull(bean1.getContent());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/json/TestJsonNullValues.java b/ebean-test/src/test/java/org/tests/json/TestJsonNullValues.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/json/TestJsonNullValues.java
rename to ebean-test/src/test/java/org/tests/json/TestJsonNullValues.java
index 7ae086e8d..593e19080 100644
--- a/ebean-core/src/test/java/org/tests/json/TestJsonNullValues.java
+++ b/ebean-test/src/test/java/org/tests/json/TestJsonNullValues.java
@@ -2,7 +2,7 @@ package org.tests.json;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicOldValue;
 
 import java.util.ArrayList;
diff --git a/ebean-core/src/test/java/org/tests/json/TestOldValue.java b/ebean-test/src/test/java/org/tests/json/TestOldValue.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/json/TestOldValue.java
rename to ebean-test/src/test/java/org/tests/json/TestOldValue.java
index f7bd391e5..63a7cda22 100644
--- a/ebean-core/src/test/java/org/tests/json/TestOldValue.java
+++ b/ebean-test/src/test/java/org/tests/json/TestOldValue.java
@@ -1,16 +1,14 @@
 package org.tests.json;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.ValuePair;
-
-import org.assertj.core.api.SoftAssertions;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.tests.model.json.EBasicOldValue;
-
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.ValuePair;
+import org.assertj.core.api.SoftAssertions;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.tests.model.json.EBasicOldValue;
 
 import java.util.List;
 import java.util.Map;
@@ -18,11 +16,9 @@ import java.util.Set;
 
 public class TestOldValue extends BaseTestCase {
 
-  
-  
   @SuppressWarnings({ "rawtypes", "unchecked" })
   @Test
-  public void testDbJsonOldValue() throws Exception {
+  public void testDbJsonOldValue() {
     EBasicOldValue bean = new EBasicOldValue();
     JsonNodeFactory jnf = new JsonNodeFactory(false);
 
@@ -35,9 +31,9 @@ public class TestOldValue extends BaseTestCase {
     bean.getIntList().add(2);
     bean.getIntSet().add(1002);
     bean.getIntMap().put("ik1",2002);
-    
+
     bean.setJsonNode(jnf.arrayNode().add("Foo"));
-    
+
     DB.save(bean);
     bean = DB.find(EBasicOldValue.class, bean.getId());
 
@@ -51,8 +47,8 @@ public class TestOldValue extends BaseTestCase {
     bean.getIntSet().add(1006);
     bean.getIntMap().put("ik2",2006);
     ((ArrayNode)bean.getJsonNode()).add("Bar");
-    
-    Map<String, ValuePair> dirty = DB.getBeanState(bean).getDirtyValues();
+
+    Map<String, ValuePair> dirty = DB.beanState(bean).dirtyValues();
     SoftAssertions softly = new SoftAssertions();
     softly.assertThat(dirty).hasSize(10);
 
@@ -83,24 +79,22 @@ public class TestOldValue extends BaseTestCase {
     softly.assertAll();
 
   }
-  
+
   @SuppressWarnings({ "rawtypes", "unchecked" })
   @Test
-  @Ignore("Old value detection does not work for @DbArray")
-  public void testDbArrayOldValue() throws Exception {
+  @Disabled("Old value detection does not work for @DbArray")
+  public void testDbArrayOldValue() {
     EBasicOldValue bean = new EBasicOldValue();
 
     bean.getStringArr().add("sa1");
-  
+
 
     DB.save(bean);
     bean = DB.find(EBasicOldValue.class, bean.getId());
 
     bean.getStringArr().add("sa2");
-    
 
-    
-    Map<String, ValuePair> dirty = DB.getBeanState(bean).getDirtyValues();
+    Map<String, ValuePair> dirty = DB.beanState(bean).dirtyValues();
     SoftAssertions softly = new SoftAssertions();
     softly.assertThat(dirty).hasSize(1);
 
@@ -108,6 +102,5 @@ public class TestOldValue extends BaseTestCase {
     softly.assertThat((List)dirty.get("stringArr").getNewValue()).containsExactly("sa1", "sa2");
 
     softly.assertAll();
-
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/json/TestUnmappedProperties.java b/ebean-test/src/test/java/org/tests/json/TestUnmappedProperties.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/json/TestUnmappedProperties.java
rename to ebean-test/src/test/java/org/tests/json/TestUnmappedProperties.java
index 095c4c011..4ab61389b 100644
--- a/ebean-core/src/test/java/org/tests/json/TestUnmappedProperties.java
+++ b/ebean-test/src/test/java/org/tests/json/TestUnmappedProperties.java
@@ -1,9 +1,9 @@
 package org.tests.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicJsonUnmapped;
-import org.junit.Test;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
@@ -29,7 +29,7 @@ public class TestUnmappedProperties extends BaseTestCase {
     bean.setUnmapped(unmapped);
 
 
-    String asJson = Ebean.json().toJson(bean);
+    String asJson = DB.json().toJson(bean);
 
     assertThat(asJson).contains("{\"name\":\"someName\",\"one\":42,\"nested\":{\"alpha\":\"aa\",\"beta\":\"bb\"}}");
 
@@ -40,7 +40,7 @@ public class TestUnmappedProperties extends BaseTestCase {
 
     String json = "{\"name\":\"someName\",\"one\":42,\"nested\":{\"alpha\":\"aa\",\"beta\":\"bb\"}}";
 
-    EBasicJsonUnmapped bean = Ebean.json().toBean(EBasicJsonUnmapped.class, json);
+    EBasicJsonUnmapped bean = DB.json().toBean(EBasicJsonUnmapped.class, json);
 
     assertThat(bean.getName()).isEqualTo("someName");
     assertThat(bean.getUnmapped().get("one")).isEqualTo(42L);
diff --git a/ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeEmptyList.java b/ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeEmptyList.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeEmptyList.java
rename to ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeEmptyList.java
index 646060eef..dcab59dcf 100644
--- a/ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeEmptyList.java
+++ b/ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeEmptyList.java
@@ -1,14 +1,14 @@
 package org.tests.json.include;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.config.JsonConfig;
 import io.ebean.text.json.JsonWriteOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
-import org.junit.Test;
 
 import java.util.ArrayList;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonExcludeEmptyList {
 
@@ -24,7 +24,7 @@ public class TestJsonExcludeEmptyList {
     JsonWriteOptions options = new JsonWriteOptions();
     options.setInclude(JsonConfig.Include.NON_NULL);
 
-    String asJson = Ebean.json().toJson(bean, options);
+    String asJson = DB.json().toJson(bean, options);
 
     String expectedJson = "{\"id\":99,\"details\":[]}";
 
@@ -43,7 +43,7 @@ public class TestJsonExcludeEmptyList {
     JsonWriteOptions options = new JsonWriteOptions();
     options.setInclude(JsonConfig.Include.NON_EMPTY);
 
-    String asJson = Ebean.json().toJson(bean, options);
+    String asJson = DB.json().toJson(bean, options);
 
     String expectedJson = "{\"id\":99}";
 
diff --git a/ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeEmptyMap.java b/ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeEmptyMap.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeEmptyMap.java
rename to ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeEmptyMap.java
index d0fc56e7e..846717a3c 100644
--- a/ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeEmptyMap.java
+++ b/ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeEmptyMap.java
@@ -1,14 +1,14 @@
 package org.tests.json.include;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.config.JsonConfig;
 import io.ebean.text.json.JsonWriteOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.model.json.EBasicJsonMap;
-import org.junit.Test;
 
 import java.util.LinkedHashMap;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonExcludeEmptyMap {
 
@@ -22,7 +22,7 @@ public class TestJsonExcludeEmptyMap {
     JsonWriteOptions options = new JsonWriteOptions();
     options.setInclude(JsonConfig.Include.NON_NULL);
 
-    String asJson = Ebean.json().toJson(bean, options);
+    String asJson = DB.json().toJson(bean, options);
 
     String expectedJson = "{\"id\":99,\"content\":{}}";
 
@@ -39,7 +39,7 @@ public class TestJsonExcludeEmptyMap {
     JsonWriteOptions options = new JsonWriteOptions();
     options.setInclude(JsonConfig.Include.NON_EMPTY);
 
-    String asJson = Ebean.json().toJson(bean, options);
+    String asJson = DB.json().toJson(bean, options);
 
     String expectedJson = "{\"id\":99,\"content\":{}}";
 
diff --git a/ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeEmptySet.java b/ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeEmptySet.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeEmptySet.java
rename to ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeEmptySet.java
index b7bdb5be5..5a24b7539 100644
--- a/ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeEmptySet.java
+++ b/ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeEmptySet.java
@@ -1,14 +1,14 @@
 package org.tests.json.include;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.config.JsonConfig;
 import io.ebean.text.json.JsonWriteOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.AttributeHolder;
-import org.junit.Test;
 
 import java.util.LinkedHashSet;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonExcludeEmptySet {
 
@@ -22,7 +22,7 @@ public class TestJsonExcludeEmptySet {
     JsonWriteOptions options = new JsonWriteOptions();
     options.setInclude(JsonConfig.Include.NON_NULL);
 
-    String asJson = Ebean.json().toJson(bean, options);
+    String asJson = DB.json().toJson(bean, options);
 
     String expectedJson = "{\"id\":99,\"attributes\":[]}";
 
@@ -39,7 +39,7 @@ public class TestJsonExcludeEmptySet {
     JsonWriteOptions options = new JsonWriteOptions();
     options.setInclude(JsonConfig.Include.NON_EMPTY);
 
-    String asJson = Ebean.json().toJson(bean, options);
+    String asJson = DB.json().toJson(bean, options);
 
     String expectedJson = "{\"id\":99}";
 
diff --git a/ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeNull.java b/ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeNull.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeNull.java
rename to ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeNull.java
index fea06e6bb..5da6413bf 100644
--- a/ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeNull.java
+++ b/ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeNull.java
@@ -1,12 +1,12 @@
 package org.tests.json.include;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.config.JsonConfig;
 import io.ebean.text.json.JsonWriteOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.json.transientproperties.EJsonTransientObject;
-import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonExcludeNull {
 
@@ -21,7 +21,7 @@ public class TestJsonExcludeNull {
     JsonWriteOptions options = new JsonWriteOptions();
     options.setInclude(JsonConfig.Include.NON_NULL);
 
-    String asJson = Ebean.json().toJson(bean, options);
+    String asJson = DB.json().toJson(bean, options);
 
     String expectedJson = "{\"id\":99}";
 
diff --git a/ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeTransientEmptyList.java b/ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeTransientEmptyList.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeTransientEmptyList.java
rename to ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeTransientEmptyList.java
index f10e67ece..03f7ac156 100644
--- a/ebean-core/src/test/java/org/tests/json/include/TestJsonExcludeTransientEmptyList.java
+++ b/ebean-test/src/test/java/org/tests/json/include/TestJsonExcludeTransientEmptyList.java
@@ -1,17 +1,17 @@
 package org.tests.json.include;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.config.JsonConfig;
 import io.ebean.text.PathProperties;
 import io.ebean.text.json.JsonWriteOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.json.transientproperties.EJsonTransientEntityList;
 import org.tests.json.transientproperties.EJsonTransientList;
-import org.junit.Test;
 
 import java.util.ArrayList;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonExcludeTransientEmptyList {
 
@@ -25,7 +25,7 @@ public class TestJsonExcludeTransientEmptyList {
     JsonWriteOptions options = new JsonWriteOptions();
     options.setInclude(JsonConfig.Include.NON_NULL);
 
-    String asJson = Ebean.json().toJson(bean, options);
+    String asJson = DB.json().toJson(bean, options);
 
     String expectedJson = "{\"id\":99,\"fileNames\":[]}";
 
@@ -42,7 +42,7 @@ public class TestJsonExcludeTransientEmptyList {
     JsonWriteOptions options = new JsonWriteOptions();
     options.setInclude(JsonConfig.Include.NON_EMPTY);
 
-    String asJson = Ebean.json().toJson(bean, options);
+    String asJson = DB.json().toJson(bean, options);
 
     String expectedJson = "{\"id\":99}";
 
@@ -58,7 +58,7 @@ public class TestJsonExcludeTransientEmptyList {
 
     PathProperties pathProps = PathProperties.parse("id,name");
 
-    String asJson = Ebean.json().toJson(bean, pathProps);
+    String asJson = DB.json().toJson(bean, pathProps);
 
     assertThat(asJson).isEqualTo("{\"id\":99,\"name\":\"John\"}");
   }
diff --git a/ebean-core/src/test/java/org/tests/json/transientproperties/EJsonJacksonIgnore.java b/ebean-test/src/test/java/org/tests/json/transientproperties/EJsonJacksonIgnore.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/json/transientproperties/EJsonJacksonIgnore.java
rename to ebean-test/src/test/java/org/tests/json/transientproperties/EJsonJacksonIgnore.java
index c835041c2..a3d937a77 100644
--- a/ebean-core/src/test/java/org/tests/json/transientproperties/EJsonJacksonIgnore.java
+++ b/ebean-test/src/test/java/org/tests/json/transientproperties/EJsonJacksonIgnore.java
@@ -1,7 +1,7 @@
 package org.tests.json.transientproperties;
 
-import io.ebean.annotation.Sql;
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import io.ebean.annotation.Sql;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
diff --git a/ebean-core/src/test/java/org/tests/json/transientproperties/EJsonTransientEntityList.java b/ebean-test/src/test/java/org/tests/json/transientproperties/EJsonTransientEntityList.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/json/transientproperties/EJsonTransientEntityList.java
rename to ebean-test/src/test/java/org/tests/json/transientproperties/EJsonTransientEntityList.java
diff --git a/ebean-core/src/test/java/org/tests/json/transientproperties/EJsonTransientList.java b/ebean-test/src/test/java/org/tests/json/transientproperties/EJsonTransientList.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/json/transientproperties/EJsonTransientList.java
rename to ebean-test/src/test/java/org/tests/json/transientproperties/EJsonTransientList.java
diff --git a/ebean-core/src/test/java/org/tests/json/transientproperties/EJsonTransientObject.java b/ebean-test/src/test/java/org/tests/json/transientproperties/EJsonTransientObject.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/json/transientproperties/EJsonTransientObject.java
rename to ebean-test/src/test/java/org/tests/json/transientproperties/EJsonTransientObject.java
diff --git a/ebean-core/src/test/java/org/tests/json/transientproperties/ModelA.java b/ebean-test/src/test/java/org/tests/json/transientproperties/ModelA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/json/transientproperties/ModelA.java
rename to ebean-test/src/test/java/org/tests/json/transientproperties/ModelA.java
diff --git a/ebean-core/src/test/java/org/tests/json/transientproperties/ModelB.java b/ebean-test/src/test/java/org/tests/json/transientproperties/ModelB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/json/transientproperties/ModelB.java
rename to ebean-test/src/test/java/org/tests/json/transientproperties/ModelB.java
diff --git a/ebean-core/src/test/java/org/tests/json/transientproperties/TestJacksonIgnore.java b/ebean-test/src/test/java/org/tests/json/transientproperties/TestJacksonIgnore.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/json/transientproperties/TestJacksonIgnore.java
rename to ebean-test/src/test/java/org/tests/json/transientproperties/TestJacksonIgnore.java
index 234e3aa8b..227723973 100644
--- a/ebean-core/src/test/java/org/tests/json/transientproperties/TestJacksonIgnore.java
+++ b/ebean-test/src/test/java/org/tests/json/transientproperties/TestJacksonIgnore.java
@@ -1,9 +1,9 @@
 package org.tests.json.transientproperties;
 
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestJacksonIgnore {
 
@@ -15,12 +15,12 @@ public class TestJacksonIgnore {
     bean.setName("foo");
     bean.setBasic(Boolean.TRUE);
 
-    String asJson = Ebean.json().toJson(bean);
+    String asJson = DB.json().toJson(bean);
 
     // ignored on write
     assertFalse(asJson.contains("basic"));
 
-    EJsonJacksonIgnore bean1 = Ebean.json().toBean(EJsonJacksonIgnore.class, asJson);
+    EJsonJacksonIgnore bean1 = DB.json().toBean(EJsonJacksonIgnore.class, asJson);
 
     assertNull(bean1.getBasic());
     assertEquals(bean.getId(), bean1.getId());
@@ -29,7 +29,7 @@ public class TestJacksonIgnore {
     // ignored on read
     String jsonFull = "{\"id\":99,\"name\":\"foo\",\"basic\":true}";
 
-    bean1 = Ebean.json().toBean(EJsonJacksonIgnore.class, jsonFull);
+    bean1 = DB.json().toBean(EJsonJacksonIgnore.class, jsonFull);
 
     assertNull(bean1.getBasic());
     assertEquals(bean.getId(), bean1.getId());
diff --git a/ebean-core/src/test/java/org/tests/json/transientproperties/TestModelAJson.java b/ebean-test/src/test/java/org/tests/json/transientproperties/TestModelAJson.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/json/transientproperties/TestModelAJson.java
rename to ebean-test/src/test/java/org/tests/json/transientproperties/TestModelAJson.java
index e81acc734..b98611738 100644
--- a/ebean-core/src/test/java/org/tests/json/transientproperties/TestModelAJson.java
+++ b/ebean-test/src/test/java/org/tests/json/transientproperties/TestModelAJson.java
@@ -1,8 +1,8 @@
 package org.tests.json.transientproperties;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.PathProperties;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 
@@ -26,7 +26,7 @@ public class TestModelAJson {
 
     PathProperties pathProperties = PathProperties.parse("(a,list(oneField))");
 
-    String json = Ebean.json().toJson(a, pathProperties);
+    String json = DB.json().toJson(a, pathProperties);
 
     assertThat(json).isEqualTo("{\"a\":\"a\",\"list\":[{\"oneField\":1}]}");
 
diff --git a/ebean-core/src/test/java/org/tests/json/transientproperties/TestTransientListProperty.java b/ebean-test/src/test/java/org/tests/json/transientproperties/TestTransientListProperty.java
similarity index 59%
rename from ebean-core/src/test/java/org/tests/json/transientproperties/TestTransientListProperty.java
rename to ebean-test/src/test/java/org/tests/json/transientproperties/TestTransientListProperty.java
index bf89a3482..9c8b4cf83 100644
--- a/ebean-core/src/test/java/org/tests/json/transientproperties/TestTransientListProperty.java
+++ b/ebean-test/src/test/java/org/tests/json/transientproperties/TestTransientListProperty.java
@@ -1,9 +1,9 @@
 package org.tests.json.transientproperties;
 
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestTransientListProperty {
 
@@ -12,12 +12,12 @@ public class TestTransientListProperty {
 
     String rawJson = "{\"basic\":true,\"fileNames\":[\"1\"]}";
 
-    EJsonTransientList bean = Ebean.json().toBean(EJsonTransientList.class, rawJson);
+    EJsonTransientList bean = DB.json().toBean(EJsonTransientList.class, rawJson);
 
     assertEquals(true, bean.getBasic());
     assertEquals(1, bean.getFileNames().size());
 
-    String asJson = Ebean.json().toJson(bean);
+    String asJson = DB.json().toJson(bean);
 
     assertEquals(rawJson, asJson);
   }
diff --git a/ebean-core/src/test/java/org/tests/json/transientproperties/TestTransientObjectProperty.java b/ebean-test/src/test/java/org/tests/json/transientproperties/TestTransientObjectProperty.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/json/transientproperties/TestTransientObjectProperty.java
rename to ebean-test/src/test/java/org/tests/json/transientproperties/TestTransientObjectProperty.java
index cfd7e54c6..fed0db613 100644
--- a/ebean-core/src/test/java/org/tests/json/transientproperties/TestTransientObjectProperty.java
+++ b/ebean-test/src/test/java/org/tests/json/transientproperties/TestTransientObjectProperty.java
@@ -1,9 +1,9 @@
 package org.tests.json.transientproperties;
 
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestTransientObjectProperty {
 
@@ -12,14 +12,14 @@ public class TestTransientObjectProperty {
 
     String rawJson = "{\"name\":\"entityBeanName\",\"basic\":true,\"someBean\":{\"name\":\"transientBeanName\",\"baz\":\"foo\"}}";
 
-    EJsonTransientObject bean = Ebean.json().toBean(EJsonTransientObject.class, rawJson);
+    EJsonTransientObject bean = DB.json().toBean(EJsonTransientObject.class, rawJson);
 
     assertEquals("entityBeanName", bean.getName());
     assertEquals(true, bean.getBasic());
     assertEquals("transientBeanName", bean.getSomeBean().name);
     assertEquals("foo", bean.getSomeBean().baz);
 
-    String asJson = Ebean.json().toJson(bean);
+    String asJson = DB.json().toJson(bean);
 
     assertEquals(rawJson, asJson);
   }
diff --git a/ebean-core/src/test/java/org/tests/lazyforeignkeys/MainEntity.java b/ebean-test/src/test/java/org/tests/lazyforeignkeys/MainEntity.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/lazyforeignkeys/MainEntity.java
rename to ebean-test/src/test/java/org/tests/lazyforeignkeys/MainEntity.java
diff --git a/ebean-core/src/test/java/org/tests/lazyforeignkeys/MainEntityRelation.java b/ebean-test/src/test/java/org/tests/lazyforeignkeys/MainEntityRelation.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/lazyforeignkeys/MainEntityRelation.java
rename to ebean-test/src/test/java/org/tests/lazyforeignkeys/MainEntityRelation.java
index 6b4740512..5da5ffdbf 100644
--- a/ebean-core/src/test/java/org/tests/lazyforeignkeys/MainEntityRelation.java
+++ b/ebean-test/src/test/java/org/tests/lazyforeignkeys/MainEntityRelation.java
@@ -2,11 +2,7 @@ package org.tests.lazyforeignkeys;
 
 import io.ebean.annotation.DbForeignKey;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.UUID;
 
 
diff --git a/ebean-core/src/test/java/org/tests/lazyforeignkeys/TestLazyForeignKeys.java b/ebean-test/src/test/java/org/tests/lazyforeignkeys/TestLazyForeignKeys.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/lazyforeignkeys/TestLazyForeignKeys.java
rename to ebean-test/src/test/java/org/tests/lazyforeignkeys/TestLazyForeignKeys.java
index 679556fe2..9d88e84ed 100644
--- a/ebean-core/src/test/java/org/tests/lazyforeignkeys/TestLazyForeignKeys.java
+++ b/ebean-test/src/test/java/org/tests/lazyforeignkeys/TestLazyForeignKeys.java
@@ -2,24 +2,21 @@ package org.tests.lazyforeignkeys;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.Query;
+import io.ebean.test.LoggedSql;
 import io.ebean.text.PathProperties;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestLazyForeignKeys extends BaseTestCase {
 
-  @Before
+  @BeforeEach
   public void prepare() {
     MainEntity ent1 = new MainEntity();
     ent1.setId("ent1");
@@ -37,7 +34,7 @@ public class TestLazyForeignKeys extends BaseTestCase {
     DB.save(rel1);
   }
 
-  @After
+  @AfterEach
   public void cleanup() {
     DB.find(MainEntity.class).delete();
     DB.find(MainEntityRelation.class).delete();
@@ -46,7 +43,7 @@ public class TestLazyForeignKeys extends BaseTestCase {
   @Test
   public void testFindOne() throws Exception {
     // use findOne without select, so lazy loading will occur
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     MainEntityRelation rel1 = DB.find(MainEntityRelation.class).findOne();
 
@@ -57,7 +54,7 @@ public class TestLazyForeignKeys extends BaseTestCase {
     assertFalse(rel1.getEntity1().isDeleted());
     assertTrue(rel1.getEntity2().isDeleted());
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("select t0.id, t0.attr1, t0.id1, t0.id2 from main_entity_relation");
     if (isSqlServer() || isOracle()) {
@@ -75,7 +72,7 @@ public class TestLazyForeignKeys extends BaseTestCase {
     pathProp.addToPath("entity1", "id");
     pathProp.addToPath("entity2", "id");
 
-    Query<MainEntityRelation> query = Ebean.find(MainEntityRelation.class).apply(pathProp);
+    Query<MainEntityRelation> query = DB.find(MainEntityRelation.class).apply(pathProp);
     List<MainEntityRelation> list = query.findList();
     assertEquals(1, list.size());
 
diff --git a/ebean-core/src/test/java/org/tests/lazyloadconf/AppConfig.java b/ebean-test/src/test/java/org/tests/lazyloadconf/AppConfig.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/lazyloadconf/AppConfig.java
rename to ebean-test/src/test/java/org/tests/lazyloadconf/AppConfig.java
diff --git a/ebean-core/src/test/java/org/tests/lazyloadconf/AppConfigControl.java b/ebean-test/src/test/java/org/tests/lazyloadconf/AppConfigControl.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/lazyloadconf/AppConfigControl.java
rename to ebean-test/src/test/java/org/tests/lazyloadconf/AppConfigControl.java
diff --git a/ebean-core/src/test/java/org/tests/lazyloadconf/BeanCollectionLazyLoadingTest.java b/ebean-test/src/test/java/org/tests/lazyloadconf/BeanCollectionLazyLoadingTest.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/lazyloadconf/BeanCollectionLazyLoadingTest.java
rename to ebean-test/src/test/java/org/tests/lazyloadconf/BeanCollectionLazyLoadingTest.java
index b0ef7592b..dea936887 100644
--- a/ebean-core/src/test/java/org/tests/lazyloadconf/BeanCollectionLazyLoadingTest.java
+++ b/ebean-test/src/test/java/org/tests/lazyloadconf/BeanCollectionLazyLoadingTest.java
@@ -2,7 +2,7 @@ package org.tests.lazyloadconf;
 
 import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.AbstractMap;
 import java.util.ArrayList;
diff --git a/ebean-core/src/test/java/org/tests/lazyloadconf/Relationship.java b/ebean-test/src/test/java/org/tests/lazyloadconf/Relationship.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/lazyloadconf/Relationship.java
rename to ebean-test/src/test/java/org/tests/lazyloadconf/Relationship.java
diff --git a/ebean-core/src/test/java/org/tests/level/Level1.java b/ebean-test/src/test/java/org/tests/level/Level1.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/level/Level1.java
rename to ebean-test/src/test/java/org/tests/level/Level1.java
index 4ddd33314..16f79a6ee 100644
--- a/ebean-core/src/test/java/org/tests/level/Level1.java
+++ b/ebean-test/src/test/java/org/tests/level/Level1.java
@@ -1,11 +1,6 @@
 package org.tests.level;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
+import javax.persistence.*;
 import java.util.Set;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/level/Level2.java b/ebean-test/src/test/java/org/tests/level/Level2.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/level/Level2.java
rename to ebean-test/src/test/java/org/tests/level/Level2.java
index d49732c0c..76d1339f4 100644
--- a/ebean-core/src/test/java/org/tests/level/Level2.java
+++ b/ebean-test/src/test/java/org/tests/level/Level2.java
@@ -1,11 +1,6 @@
 package org.tests.level;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/level/Level3.java b/ebean-test/src/test/java/org/tests/level/Level3.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/level/Level3.java
rename to ebean-test/src/test/java/org/tests/level/Level3.java
diff --git a/ebean-core/src/test/java/org/tests/level/Level4.java b/ebean-test/src/test/java/org/tests/level/Level4.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/level/Level4.java
rename to ebean-test/src/test/java/org/tests/level/Level4.java
diff --git a/ebean-core/src/test/java/org/tests/level/test/ManyToManyTest.java b/ebean-test/src/test/java/org/tests/level/test/ManyToManyTest.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/level/test/ManyToManyTest.java
rename to ebean-test/src/test/java/org/tests/level/test/ManyToManyTest.java
index 52cf6098f..73675df63 100644
--- a/ebean-core/src/test/java/org/tests/level/test/ManyToManyTest.java
+++ b/ebean-test/src/test/java/org/tests/level/test/ManyToManyTest.java
@@ -1,45 +1,45 @@
 package org.tests.level.test;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.level.Level1;
 import org.tests.level.Level2;
 import org.tests.level.Level3;
 import org.tests.level.Level4;
-import org.junit.Test;
 
 import java.util.List;
 import java.util.Set;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class ManyToManyTest extends BaseTestCase {
 
   @Test
   public void test() {
 
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
       Level4 i = new Level4("i");
       Level4 ii = new Level4("ii");
       Level4 iii = new Level4("iii");
 
-      Ebean.save(i);
-      Ebean.save(ii);
-      Ebean.save(iii);
+      DB.save(i);
+      DB.save(ii);
+      DB.save(iii);
 
       Level3 a = new Level3("a");
       Level3 b = new Level3("b");
 
-      Ebean.save(a);
-      Ebean.save(b);
+      DB.save(a);
+      DB.save(b);
 
       Level2 one = new Level2("one");
       Level2 two = new Level2("two");
 
-      Ebean.save(one);
-      Ebean.save(two);
+      DB.save(one);
+      DB.save(two);
 
       Level1 x1 = new Level1("x1");
       Level1 x2 = new Level1("x2");
@@ -58,14 +58,14 @@ public class ManyToManyTest extends BaseTestCase {
       x2.getLevel4s().add(ii);
       x2.getLevel4s().add(iii);
 
-      Ebean.save(x1);
-      Ebean.save(x2);
-      Ebean.save(x3);
-      Ebean.save(x4);
-      Ebean.save(x5);
+      DB.save(x1);
+      DB.save(x2);
+      DB.save(x3);
+      DB.save(x4);
+      DB.save(x5);
 
       // this query had the original problem
-      List<Level1> things = Ebean.find(Level1.class)
+      List<Level1> things = DB.find(Level1.class)
         .fetch("level4s")
         .fetch("level2s")
         .fetch("level2s.level3s")
@@ -75,7 +75,7 @@ public class ManyToManyTest extends BaseTestCase {
       validateObjectGraph(i, ii, iii, one, two, x1, x2, x3, x4, x5, things);
 
 
-      things = Ebean.find(Level1.class)
+      things = DB.find(Level1.class)
         .fetch("level2s")
         .fetch("level2s.level3s")
         .fetch("level4s")
@@ -85,7 +85,7 @@ public class ManyToManyTest extends BaseTestCase {
       validateObjectGraph(i, ii, iii, one, two, x1, x2, x3, x4, x5, things);
 
 
-      things = Ebean.find(Level1.class)
+      things = DB.find(Level1.class)
         .fetch("level2s")
         .fetch("level4s")
         .order().asc("id")
@@ -94,7 +94,7 @@ public class ManyToManyTest extends BaseTestCase {
       validateObjectGraph(i, ii, iii, one, two, x1, x2, x3, x4, x5, things);
 
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
   }
 
diff --git a/ebean-core/src/test/java/org/tests/lifecycle/TestLifecycleAnnotatedBean.java b/ebean-test/src/test/java/org/tests/lifecycle/TestLifecycleAnnotatedBean.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/lifecycle/TestLifecycleAnnotatedBean.java
rename to ebean-test/src/test/java/org/tests/lifecycle/TestLifecycleAnnotatedBean.java
index 8ecd7cdcf..9700a1229 100644
--- a/ebean-core/src/test/java/org/tests/lifecycle/TestLifecycleAnnotatedBean.java
+++ b/ebean-test/src/test/java/org/tests/lifecycle/TestLifecycleAnnotatedBean.java
@@ -2,11 +2,10 @@ package org.tests.lifecycle;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicWithLifecycle;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -18,7 +17,7 @@ public class TestLifecycleAnnotatedBean extends BaseTestCase {
     EBasicWithLifecycle bean = new EBasicWithLifecycle();
     bean.setName("PrePersist");
 
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertThat(bean.getBuffer()).contains("prePersist1");
     assertThat(bean.getBuffer()).contains("prePersist2");
@@ -30,7 +29,7 @@ public class TestLifecycleAnnotatedBean extends BaseTestCase {
     EBasicWithLifecycle bean = new EBasicWithLifecycle();
     bean.setName("PostPersist");
 
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertThat(bean.getBuffer()).contains("postPersist1");
     assertThat(bean.getBuffer()).contains("postPersist2");
@@ -42,9 +41,9 @@ public class TestLifecycleAnnotatedBean extends BaseTestCase {
     EBasicWithLifecycle bean = new EBasicWithLifecycle();
     bean.setName("PostLoad");
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicWithLifecycle loaded = Ebean.find(EBasicWithLifecycle.class, bean.getId());
+    EBasicWithLifecycle loaded = DB.find(EBasicWithLifecycle.class, bean.getId());
     assertThat(loaded.getBuffer()).contains("postLoad1");
     assertThat(loaded.getBuffer()).contains("postLoad2");
   }
@@ -55,10 +54,10 @@ public class TestLifecycleAnnotatedBean extends BaseTestCase {
     EBasicWithLifecycle bean = new EBasicWithLifecycle();
     bean.setName("Persisted");
 
-    Ebean.save(bean);
+    DB.save(bean);
 
     bean.setName("PreUpdate");
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertThat(bean.getBuffer()).contains("preUpdate1");
     assertThat(bean.getBuffer()).contains("preUpdate2");
@@ -87,10 +86,10 @@ public class TestLifecycleAnnotatedBean extends BaseTestCase {
     EBasicWithLifecycle bean = new EBasicWithLifecycle();
     bean.setName("Persisted");
 
-    Ebean.save(bean);
+    DB.save(bean);
 
     bean.setName("PostUpdate");
-    Ebean.save(bean);
+    DB.save(bean);
 
     assertThat(bean.getBuffer()).contains("postUpdate1");
     assertThat(bean.getBuffer()).contains("postUpdate2");
@@ -102,13 +101,13 @@ public class TestLifecycleAnnotatedBean extends BaseTestCase {
     EBasicWithLifecycle bean = new EBasicWithLifecycle();
     bean.setName("Persisted");
 
-    Ebean.save(bean);
-    Ebean.delete(bean);
+    DB.save(bean);
+    DB.delete(bean);
 
     assertThat(bean.getBuffer()).contains("preSoftDelete");
     assertThat(bean.getBuffer()).contains("postSoftDelete");
 
-    Ebean.deletePermanent(bean);
+    DB.deletePermanent(bean);
 
     assertThat(bean.getBuffer()).contains("preRemove1");
     assertThat(bean.getBuffer()).contains("preRemove2");
@@ -122,8 +121,8 @@ public class TestLifecycleAnnotatedBean extends BaseTestCase {
     EBasicWithLifecycle bean = new EBasicWithLifecycle();
     bean.setName("Persisted");
 
-    Ebean.save(bean);
-    Ebean.deletePermanent(bean);
+    DB.save(bean);
+    DB.deletePermanent(bean);
 
     assertThat(bean.getBuffer()).contains("postRemove1");
     assertThat(bean.getBuffer()).contains("postRemove2");
@@ -135,9 +134,9 @@ public class TestLifecycleAnnotatedBean extends BaseTestCase {
     EBasicWithLifecycle bean = new EBasicWithLifecycle();
     bean.setName("PostConstruct");
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    EBasicWithLifecycle loaded = Ebean.find(EBasicWithLifecycle.class, bean.getId());
+    EBasicWithLifecycle loaded = DB.find(EBasicWithLifecycle.class, bean.getId());
     assertThat(loaded.getBuffer()).contains("postConstruct1");
     assertThat(loaded.getBuffer()).contains("postConstruct2");
     // assert also that postLoad was executed
@@ -147,7 +146,7 @@ public class TestLifecycleAnnotatedBean extends BaseTestCase {
 
   @Test
   public void shouldExecutePostConstructMethodsWhenInstantiated() {
-    EBasicWithLifecycle bean = Ebean.getDefaultServer().createEntityBean(EBasicWithLifecycle.class);
+    EBasicWithLifecycle bean = DB.getDefault().createEntityBean(EBasicWithLifecycle.class);
     bean.setName("PostConstruct");
 
 
@@ -165,9 +164,9 @@ public class TestLifecycleAnnotatedBean extends BaseTestCase {
     EBasicWithLifecycle bean = new EBasicWithLifecycle();
     bean.setName("LazyLoad");
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    BeanDescriptor<EBasicWithLifecycle> desc = ((SpiEbeanServer) server()).getBeanDescriptor(EBasicWithLifecycle.class);
+    BeanDescriptor<EBasicWithLifecycle> desc = ((SpiEbeanServer) server()).descriptor(EBasicWithLifecycle.class);
     EBasicWithLifecycle loaded = desc.createReference(false, false, bean.getId(), null);
 
     // Here you see the big difference.
diff --git a/ebean-core/src/test/java/org/tests/lifecycle/TestLifecycleExceptions.java b/ebean-test/src/test/java/org/tests/lifecycle/TestLifecycleExceptions.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/lifecycle/TestLifecycleExceptions.java
rename to ebean-test/src/test/java/org/tests/lifecycle/TestLifecycleExceptions.java
index 3e5ddf4a3..48efd17ec 100644
--- a/ebean-core/src/test/java/org/tests/lifecycle/TestLifecycleExceptions.java
+++ b/ebean-test/src/test/java/org/tests/lifecycle/TestLifecycleExceptions.java
@@ -2,14 +2,13 @@ package org.tests.lifecycle;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicWithLifecycleExceptions;
-import org.junit.Test;
-
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-import java.io.IOException;
 
 import javax.persistence.PersistenceException;
+import java.io.IOException;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 public class TestLifecycleExceptions extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/lifecycle/TestLifecycleWithLog.java b/ebean-test/src/test/java/org/tests/lifecycle/TestLifecycleWithLog.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/lifecycle/TestLifecycleWithLog.java
rename to ebean-test/src/test/java/org/tests/lifecycle/TestLifecycleWithLog.java
index 56bb64311..67841cff6 100644
--- a/ebean-core/src/test/java/org/tests/lifecycle/TestLifecycleWithLog.java
+++ b/ebean-test/src/test/java/org/tests/lifecycle/TestLifecycleWithLog.java
@@ -1,16 +1,15 @@
 package org.tests.lifecycle;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.EBasicLog;
+import org.tests.model.basic.EBasicWithLog;
 
 import java.util.Arrays;
 import java.util.List;
 
-import org.junit.Test;
-import org.tests.model.basic.EBasicLog;
-import org.tests.model.basic.EBasicWithLog;
-
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestLifecycleWithLog extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteCascadeFromParent.java b/ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteCascadeFromParent.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteCascadeFromParent.java
rename to ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteCascadeFromParent.java
index f8e2189e3..12f2f9806 100644
--- a/ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteCascadeFromParent.java
+++ b/ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteCascadeFromParent.java
@@ -3,12 +3,12 @@ package org.tests.m2m;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.SqlRow;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.m2m.MnyA;
 import org.tests.model.m2m.MnyB;
 import org.tests.model.m2m.MnyC;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestM2MDeleteCascadeFromParent extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteNoCascade.java b/ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteNoCascade.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteNoCascade.java
rename to ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteNoCascade.java
index fde4594fb..415f56c97 100644
--- a/ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteNoCascade.java
+++ b/ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteNoCascade.java
@@ -5,9 +5,9 @@ import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MnocRole;
 import org.tests.model.basic.MnocUser;
 
@@ -22,7 +22,7 @@ public class TestM2MDeleteNoCascade extends BaseTestCase {
   private static MnocRole r1 = new MnocRole("r1");
   private static MnocRole r2 = new MnocRole("r2");
 
-  @BeforeClass
+  @BeforeAll
   public static void setup() {
     DB.save(r0);
     DB.save(r1);
@@ -43,10 +43,10 @@ public class TestM2MDeleteNoCascade extends BaseTestCase {
     List<MnocRole> validRoles = loadedUser.getValidRoles();
     assertThat(validRoles).hasSize(2);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.delete(u0);
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from mnoc_user_mnoc_role where mnoc_user_user_id = ?");
     assertSql(sql.get(1)).contains("delete from mnoc_user where user_id=? and version=?");
@@ -71,10 +71,10 @@ public class TestM2MDeleteNoCascade extends BaseTestCase {
     user.setUserName("usr1-mod");
     user.setValidRoles(roles);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.update(user);
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(5);
     assertSql(sql.get(0)).contains("update mnoc_user set user_name=?, version=? where user_id=? and version=?");
     assertSql(sql.get(1)).contains("delete from mnoc_user_mnoc_role where mnoc_user_user_id = ?");
@@ -97,7 +97,7 @@ public class TestM2MDeleteNoCascade extends BaseTestCase {
     DB.save(u0);
     DB.save(u1);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     try (Transaction txn = DB.beginTransaction()) {
       txn.setBatchMode(true);
@@ -106,7 +106,7 @@ public class TestM2MDeleteNoCascade extends BaseTestCase {
       txn.commit();
     }
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(8);
     assertSql(sql.get(0)).contains("delete from mnoc_user_mnoc_role where mnoc_user_user_id = ?");
     assertThat(sql.get(4)).contains("delete from mnoc_user_mnoc_role where mnoc_user_user_id = ?");
diff --git a/ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteObjectWithCascadeToM2m.java b/ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteObjectWithCascadeToM2m.java
new file mode 100644
index 000000000..b60af0b06
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteObjectWithCascadeToM2m.java
@@ -0,0 +1,64 @@
+package org.tests.m2m;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.m2m.Permission;
+import org.tests.model.m2m.Role;
+import org.tests.model.m2m.Tenant;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TestM2MDeleteObjectWithCascadeToM2m extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    DB.createUpdate(Permission.class, "delete from Permission").execute();
+    DB.createUpdate(Tenant.class, "delete from Tenant").execute();
+    DB.createUpdate(Role.class, "delete from Role").execute();
+
+    Tenant tenant1 = new Tenant("Tenant");
+    DB.save(tenant1);
+
+    Permission p1 = new Permission("p1");
+    Permission p2 = new Permission("p2");
+    DB.save(p1);
+    DB.save(p2);
+
+    Role role1 = new Role("RoleOne");
+    role1.setTenant(tenant1);
+
+    Set<Permission> permissions = new HashSet<>();
+    List<Permission> permsList = DB.find(Permission.class).findList();
+    permissions.addAll(permsList);
+
+    role1.setPermissions(permissions);
+
+    DB.save(role1);
+
+
+    List<Tenant> tenantList = DB.find(Tenant.class).fetch("roles").findList();
+    List<Role> roleList = DB.find(Role.class).fetch("permissions").findList();
+    List<Permission> permissionList = DB.find(Permission.class).fetch("roles").findList();
+
+    assertEquals(1, tenantList.size());
+    assertEquals(2, permissionList.size());
+    assertEquals(1, roleList.size());
+
+    DB.delete(tenant1);
+
+    List<Tenant> tenantList2 = DB.find(Tenant.class).fetch("roles").findList();
+    List<Role> roleList2 = DB.find(Role.class).fetch("permissions").findList();
+    List<Permission> permissionList2 = DB.find(Permission.class).fetch("roles").findList();
+
+    assertEquals(0, tenantList2.size());
+    assertEquals(0, roleList2.size());
+    assertEquals(2, permissionList2.size());
+
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteWithCascade.java b/ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteWithCascade.java
similarity index 53%
rename from ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteWithCascade.java
rename to ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteWithCascade.java
index ac44be657..6d996c61c 100644
--- a/ebean-core/src/test/java/org/tests/m2m/TestM2MDeleteWithCascade.java
+++ b/ebean-test/src/test/java/org/tests/m2m/TestM2MDeleteWithCascade.java
@@ -1,16 +1,18 @@
 package org.tests.m2m;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MRole;
 import org.tests.model.basic.MUser;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
 public class TestM2MDeleteWithCascade extends BaseTestCase {
 
   @Test
@@ -19,34 +21,34 @@ public class TestM2MDeleteWithCascade extends BaseTestCase {
     MRole r0 = new MRole("r0");
     MRole r1 = new MRole("r1");
 
-    Ebean.save(r0);
-    // Ebean.save(r1);
+    DB.save(r0);
+    // DB.save(r1);
 
     MUser u0 = new MUser("usr0");
     u0.addRole(r0);
     u0.addRole(r1);
 
-    Ebean.save(u0);
+    DB.save(u0);
 
     List<MRole> roles = u0.getRoles();
 
     // this will delete
-    Ebean.delete(u0);
+    DB.delete(u0);
 
-    MUser notThere = Ebean.find(MUser.class, u0.getUserid());
-    Assert.assertNull("been deleted", notThere);
+    MUser notThere = DB.find(MUser.class, u0.getUserid());
+    assertNull(notThere);
 
     List<Object> roleIds = new ArrayList<>();
     Collections.addAll(roleIds, r0.getRoleid(), r1.getRoleid());
 
-    int rc = Ebean.find(MRole.class).where().idIn(roleIds).findCount();
+    int rc = DB.find(MRole.class).where().idIn(roleIds).findCount();
 
-    Assert.assertEquals("roles not deleted", 2, rc);
+    assertEquals(2, rc);
 
-    Ebean.deleteAll(roles);
+    DB.deleteAll(roles);
 
-    rc = Ebean.find(MRole.class).where().idIn(roleIds).findCount();
+    rc = DB.find(MRole.class).where().idIn(roleIds).findCount();
 
-    Assert.assertEquals("roles deleted now", 0, rc);
+    assertEquals(0, rc);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/m2m/TestM2MDistinct_sqlServer.java b/ebean-test/src/test/java/org/tests/m2m/TestM2MDistinct_sqlServer.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/m2m/TestM2MDistinct_sqlServer.java
rename to ebean-test/src/test/java/org/tests/m2m/TestM2MDistinct_sqlServer.java
index 29c216ce7..cf10512cd 100644
--- a/ebean-core/src/test/java/org/tests/m2m/TestM2MDistinct_sqlServer.java
+++ b/ebean-test/src/test/java/org/tests/m2m/TestM2MDistinct_sqlServer.java
@@ -4,8 +4,8 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import io.ebeantest.LoggedSql;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.m2m.Permission;
 import org.tests.model.m2m.Role;
 
@@ -29,8 +29,8 @@ public class TestM2MDistinct_sqlServer extends BaseTestCase {
 
     List<String> sqls = LoggedSql.stop();
     assertThat(sqls.get(0)).startsWith("select distinct t0.id, t0.name, t0.version, t0.tenant_id, t0.name collate Latin1_General_CI_AS "
-      + "from mt_role t0 join mt_role_permission u1z_ on u1z_.mt_role_id = t0.id  "
-      + "join mt_permission u1 on u1.id = u1z_.mt_permission_id  where u1.id = ? "
+      + "from mt_role t0 join mt_role_permission u1z_ on u1z_.mt_role_id = t0.id "
+      + "join mt_permission u1 on u1.id = u1z_.mt_permission_id where u1.id = ? "
       + "order by t0.name collate Latin1_General_CI_AS;");
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/m2m/TestM2MModifyTest.java b/ebean-test/src/test/java/org/tests/m2m/TestM2MModifyTest.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/m2m/TestM2MModifyTest.java
rename to ebean-test/src/test/java/org/tests/m2m/TestM2MModifyTest.java
index 3a50fa547..7089bedca 100644
--- a/ebean-core/src/test/java/org/tests/m2m/TestM2MModifyTest.java
+++ b/ebean-test/src/test/java/org/tests/m2m/TestM2MModifyTest.java
@@ -2,7 +2,7 @@ package org.tests.m2m;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MRole;
 import org.tests.model.basic.MUser;
 
diff --git a/ebean-core/src/test/java/org/tests/m2m/TestM2MMultipleLists.java b/ebean-test/src/test/java/org/tests/m2m/TestM2MMultipleLists.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/m2m/TestM2MMultipleLists.java
rename to ebean-test/src/test/java/org/tests/m2m/TestM2MMultipleLists.java
index a1f9db3eb..425ae3812 100644
--- a/ebean-core/src/test/java/org/tests/m2m/TestM2MMultipleLists.java
+++ b/ebean-test/src/test/java/org/tests/m2m/TestM2MMultipleLists.java
@@ -1,12 +1,12 @@
 package org.tests.m2m;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.m2m.MailBox;
 import org.tests.model.m2m.MailUser;
-import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestM2MMultipleLists extends BaseTestCase {
 
@@ -20,9 +20,9 @@ public class TestM2MMultipleLists extends BaseTestCase {
     m1.setName("mailBox1");
 
     u.getInbox().add(m1);
-    Ebean.save(u);
+    DB.save(u);
 
-    u = Ebean.find(MailUser.class, u.getId());
+    u = DB.find(MailUser.class, u.getId());
 
     assertEquals(1, u.getInbox().size());
     assertEquals(0, u.getOutbox().size());
diff --git a/ebean-core/src/test/java/org/tests/m2m/TestM2MSelfRelationship.java b/ebean-test/src/test/java/org/tests/m2m/TestM2MSelfRelationship.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/m2m/TestM2MSelfRelationship.java
rename to ebean-test/src/test/java/org/tests/m2m/TestM2MSelfRelationship.java
index 1683f5aa8..0cd6ca95d 100644
--- a/ebean-core/src/test/java/org/tests/m2m/TestM2MSelfRelationship.java
+++ b/ebean-test/src/test/java/org/tests/m2m/TestM2MSelfRelationship.java
@@ -1,9 +1,9 @@
 package org.tests.m2m;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.m2m.MnyTopic;
-import org.junit.Test;
 
 /**
  * Added to test DDL generation for ManyToMany related back to itself.
@@ -13,17 +13,17 @@ public class TestM2MSelfRelationship extends BaseTestCase {
   @Test
   public void test() {
 
-    Ebean.getDefaultServer();
+    DB.getDefault();
 
     // Create 2 roles r0 and r1
     MnyTopic r0 = new MnyTopic("r0");
     MnyTopic r1 = new MnyTopic("r1");
 
     // Save r1 and r2
-    Ebean.save(r0);
-    Ebean.save(r1);
+    DB.save(r0);
+    DB.save(r1);
 
     r0.getSubTopics().add(r1);
-    Ebean.save(r0);
+    DB.save(r0);
   }
 }
diff --git a/ebean-test/src/test/java/org/tests/m2m/TestM2mDeleteObject.java b/ebean-test/src/test/java/org/tests/m2m/TestM2mDeleteObject.java
new file mode 100644
index 000000000..c7b3d1f5b
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/m2m/TestM2mDeleteObject.java
@@ -0,0 +1,94 @@
+package org.tests.m2m;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.meta.MetaTimedMetric;
+import org.junit.jupiter.api.Test;
+import org.tests.model.m2m.Permission;
+import org.tests.model.m2m.Role;
+import org.tests.model.m2m.Tenant;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TestM2mDeleteObject extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    resetAllMetrics();
+
+    DB.createUpdate(Permission.class, "delete from Permission").setLabel("deleteAllPermissions").execute();
+    DB.createUpdate(Tenant.class, "delete from Tenant").execute();
+    DB.createUpdate(Role.class, "delete from Role").execute();
+
+    List<MetaTimedMetric> sqlMetrics = sqlMetrics();
+    assertThat(sqlMetrics).hasSize(1);
+    assertThat(sqlMetrics.get(0).name()).isEqualTo("orm.update.deleteAllPermissions");
+
+    Tenant t = new Tenant("tenant");
+
+    DB.save(t);
+
+    Permission p1 = new Permission("p1");
+    Permission p2 = new Permission("p2");
+
+    DB.save(p1);
+    DB.save(p2);
+
+    Role role1 = new Role("role");
+    role1.setTenant(t);
+
+    Set<Permission> permissions = new HashSet<>();
+    List<Permission> permsList = DB.find(Permission.class).findList();
+    permissions.addAll(permsList);
+
+    role1.setPermissions(permissions);
+
+    DB.save(role1);
+
+    List<Tenant> tenantList = DB.find(Tenant.class).fetch("roles").findList();
+    List<Role> roleList = DB.find(Role.class).fetch("permissions").findList();
+    List<Permission> permissionList = DB.find(Permission.class).fetch("roles").findList();
+
+    assertEquals(1, tenantList.size());
+    assertEquals(2, permissionList.size());
+    assertEquals(1, roleList.size());
+
+    DB.delete(role1);
+
+    List<Tenant> tenantList2 = DB.find(Tenant.class).fetch("roles").findList();
+    List<Role> roleList2 = DB.find(Role.class).fetch("permissions").findList();
+    List<Permission> permissionList2 = DB.find(Permission.class).fetch("roles").findList();
+
+    assertEquals(0, roleList2.size());
+    assertEquals(1, tenantList2.size());
+    assertEquals(2, permissionList2.size());
+  }
+
+
+  @Test
+  public void test_deleteCascading() {
+
+    Permission p1 = new Permission("p1");
+    Permission p2 = new Permission("p2");
+    DB.save(p1);
+    DB.save(p2);
+
+    Role role1 = new Role("role");
+
+    Set<Permission> permissions = new HashSet<>();
+    permissions.add(p2);
+    role1.setPermissions(permissions);
+    DB.save(role1);
+
+    // only deletes as not associated
+    DB.delete(p1);
+    // delete cascades
+    DB.delete(role1);
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/m2m/softdelete/MsManyA.java b/ebean-test/src/test/java/org/tests/m2m/softdelete/MsManyA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/m2m/softdelete/MsManyA.java
rename to ebean-test/src/test/java/org/tests/m2m/softdelete/MsManyA.java
diff --git a/ebean-core/src/test/java/org/tests/m2m/softdelete/MsManyB.java b/ebean-test/src/test/java/org/tests/m2m/softdelete/MsManyB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/m2m/softdelete/MsManyB.java
rename to ebean-test/src/test/java/org/tests/m2m/softdelete/MsManyB.java
diff --git a/ebean-core/src/test/java/org/tests/m2m/softdelete/TestM2MSoftDeleteExists.java b/ebean-test/src/test/java/org/tests/m2m/softdelete/TestM2MSoftDeleteExists.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/m2m/softdelete/TestM2MSoftDeleteExists.java
rename to ebean-test/src/test/java/org/tests/m2m/softdelete/TestM2MSoftDeleteExists.java
index 2dbd07c90..c8fe1498b 100644
--- a/ebean-core/src/test/java/org/tests/m2m/softdelete/TestM2MSoftDeleteExists.java
+++ b/ebean-test/src/test/java/org/tests/m2m/softdelete/TestM2MSoftDeleteExists.java
@@ -1,15 +1,15 @@
 package org.tests.m2m.softdelete;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestM2MSoftDeleteExists extends BaseTestCase {
 
@@ -21,7 +21,7 @@ public class TestM2MSoftDeleteExists extends BaseTestCase {
 
     setup();
 
-    Query<MsManyA> query = Ebean.find(MsManyA.class)
+    Query<MsManyA> query = DB.find(MsManyA.class)
       .where().isNotEmpty("manybs")
       .order("aid").query();
 
@@ -41,9 +41,9 @@ public class TestM2MSoftDeleteExists extends BaseTestCase {
 
   private void testDeletedB0() {
 
-    Ebean.delete(bs.get(0));
+    DB.delete(bs.get(0));
 
-    List<MsManyA> list = Ebean.find(MsManyA.class)
+    List<MsManyA> list = DB.find(MsManyA.class)
       .where().isNotEmpty("manybs")
       .order("aid")
       .findList();
@@ -57,9 +57,9 @@ public class TestM2MSoftDeleteExists extends BaseTestCase {
 
   private void testDeletedB1() {
 
-    Ebean.delete(bs.get(1));
+    DB.delete(bs.get(1));
 
-    List<MsManyA> list = Ebean.find(MsManyA.class)
+    List<MsManyA> list = DB.find(MsManyA.class)
       .where().isNotEmpty("manybs")
       .order("aid")
       .findList();
@@ -72,9 +72,9 @@ public class TestM2MSoftDeleteExists extends BaseTestCase {
 
   private void testEndTotals() {
 
-    assertEquals(5, Ebean.find(MsManyA.class).findCount());
-    assertEquals(3, Ebean.find(MsManyB.class).findCount());
-    assertEquals(5, Ebean.find(MsManyB.class).setIncludeSoftDeletes().findCount());
+    assertEquals(5, DB.find(MsManyA.class).findCount());
+    assertEquals(3, DB.find(MsManyB.class).findCount());
+    assertEquals(5, DB.find(MsManyB.class).setIncludeSoftDeletes().findCount());
   }
 
   private void setup() {
@@ -84,9 +84,9 @@ public class TestM2MSoftDeleteExists extends BaseTestCase {
 
   private void clean() {
 
-    Ebean.createSqlUpdate("delete from ms_many_a_many_b").execute();
-    Ebean.createSqlUpdate("delete from ms_many_a").execute();
-    Ebean.createSqlUpdate("delete from ms_many_b").execute();
+    DB.sqlUpdate("delete from ms_many_a_many_b").execute();
+    DB.sqlUpdate("delete from ms_many_a").execute();
+    DB.sqlUpdate("delete from ms_many_b").execute();
   }
 
   private void seed() {
@@ -95,16 +95,16 @@ public class TestM2MSoftDeleteExists extends BaseTestCase {
       bs.add(new MsManyB("b" + i));
     }
 
-    Ebean.saveAll(as);
-    Ebean.saveAll(bs);
+    DB.saveAll(as);
+    DB.saveAll(bs);
 
     as.get(0).getManybs().add(bs.get(0));
     as.get(1).getManybs().addAll(bs);
     as.get(2).getManybs().add(bs.get(1));
 
-    Ebean.save(as.get(0));
-    Ebean.save(as.get(1));
-    Ebean.save(as.get(2));
+    DB.save(as.get(0));
+    DB.save(as.get(1));
+    DB.save(as.get(2));
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/merge/MAddress.java b/ebean-test/src/test/java/org/tests/merge/MAddress.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/merge/MAddress.java
rename to ebean-test/src/test/java/org/tests/merge/MAddress.java
diff --git a/ebean-core/src/test/java/org/tests/merge/MBase.java b/ebean-test/src/test/java/org/tests/merge/MBase.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/merge/MBase.java
rename to ebean-test/src/test/java/org/tests/merge/MBase.java
diff --git a/ebean-core/src/test/java/org/tests/merge/MContact.java b/ebean-test/src/test/java/org/tests/merge/MContact.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/merge/MContact.java
rename to ebean-test/src/test/java/org/tests/merge/MContact.java
diff --git a/ebean-core/src/test/java/org/tests/merge/MContactMessage.java b/ebean-test/src/test/java/org/tests/merge/MContactMessage.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/merge/MContactMessage.java
rename to ebean-test/src/test/java/org/tests/merge/MContactMessage.java
diff --git a/ebean-core/src/test/java/org/tests/merge/MCustomer.java b/ebean-test/src/test/java/org/tests/merge/MCustomer.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/merge/MCustomer.java
rename to ebean-test/src/test/java/org/tests/merge/MCustomer.java
diff --git a/ebean-core/src/test/java/org/tests/merge/MGroup.java b/ebean-test/src/test/java/org/tests/merge/MGroup.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/merge/MGroup.java
rename to ebean-test/src/test/java/org/tests/merge/MGroup.java
diff --git a/ebean-core/src/test/java/org/tests/merge/MMachine.java b/ebean-test/src/test/java/org/tests/merge/MMachine.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/merge/MMachine.java
rename to ebean-test/src/test/java/org/tests/merge/MMachine.java
diff --git a/ebean-core/src/test/java/org/tests/merge/TestMergeBasic.java b/ebean-test/src/test/java/org/tests/merge/TestMergeBasic.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/merge/TestMergeBasic.java
rename to ebean-test/src/test/java/org/tests/merge/TestMergeBasic.java
index 1e274d6bb..5ab159089 100644
--- a/ebean-core/src/test/java/org/tests/merge/TestMergeBasic.java
+++ b/ebean-test/src/test/java/org/tests/merge/TestMergeBasic.java
@@ -1,11 +1,11 @@
 package org.tests.merge;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.MergeOptions;
 import io.ebean.MergeOptionsBuilder;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UUOne;
 import org.tests.model.basic.UUTwo;
 
@@ -18,13 +18,13 @@ public class TestMergeBasic extends BaseTestCase {
 
 
   private UUOne rebuildViaJson(UUOne input) {
-    String asJson = Ebean.json().toJson(input);
-    return Ebean.json().toBean(UUOne.class, asJson);
+    String asJson = DB.json().toJson(input);
+    return DB.json().toBean(UUOne.class, asJson);
   }
 
   private UUOne build() {
     UUOne uuOne = buildGraph();
-    Ebean.save(uuOne);
+    DB.save(uuOne);
     return rebuildViaJson(uuOne);
   }
 
@@ -44,11 +44,11 @@ public class TestMergeBasic extends BaseTestCase {
       .setClientGeneratedIds()
       .build();
 
-    LoggedSqlCollector.start();
-    Ebean.merge(one, options);
+    LoggedSql.start();
+    DB.merge(one, options);
 
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     // fetch the Ids ... used to identity inserts, updates and deletes
     assertSql(sql.get(0)).contains("select t0.id, t1.id from uuone t0 left join uutwo t1 on t1.master_id = t0.id where t0.id = ?");
 
@@ -92,11 +92,11 @@ public class TestMergeBasic extends BaseTestCase {
       .addPath("comments")
       .build();
 
-    LoggedSqlCollector.start();
-    Ebean.merge(one, options);
+    LoggedSql.start();
+    DB.merge(one, options);
 
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     // fetch the Ids ... used to identity inserts, updates and deletes
     assertSql(sql.get(0)).contains("select t0.id, t1.id from uuone t0 left join uutwo t1 on t1.master_id = t0.id where t0.id = ?");
 
diff --git a/ebean-core/src/test/java/org/tests/merge/TestMergeCustomer.java b/ebean-test/src/test/java/org/tests/merge/TestMergeCustomer.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/merge/TestMergeCustomer.java
rename to ebean-test/src/test/java/org/tests/merge/TestMergeCustomer.java
index 61a1a9cfc..43928257d 100644
--- a/ebean-core/src/test/java/org/tests/merge/TestMergeCustomer.java
+++ b/ebean-test/src/test/java/org/tests/merge/TestMergeCustomer.java
@@ -1,13 +1,9 @@
 package org.tests.merge;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchPath;
-import io.ebean.MergeOptions;
-import io.ebean.MergeOptionsBuilder;
+import io.ebean.*;
+import io.ebean.test.LoggedSql;
 import io.ebean.text.PathProperties;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -26,11 +22,11 @@ public class TestMergeCustomer extends BaseTestCase {
     MCustomer mCustomer = partial("cust1", "(id,name,version)");
     mCustomer.setName("NotCust0");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.merge(mCustomer);
+    DB.merge(mCustomer);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("update mcustomer set name=?, version=? where id=? and version=?");
   }
@@ -48,11 +44,11 @@ public class TestMergeCustomer extends BaseTestCase {
     MergeOptions options = new MergeOptionsBuilder().build();
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.merge(mCustomer, options);
+    DB.merge(mCustomer, options);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("update mcustomer set name=?, version=? where id=? and version=?");
   }
@@ -66,11 +62,11 @@ public class TestMergeCustomer extends BaseTestCase {
 
     MergeOptions options = new MergeOptionsBuilder().setClientGeneratedIds().build();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     server().merge(mCustomer, options);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.id from mcustomer t0 where t0.id = ?");
     assertSql(sql.get(1)).contains("update mcustomer set name=?, version=? where id=? and version=?");
@@ -90,11 +86,11 @@ public class TestMergeCustomer extends BaseTestCase {
       .setClientGeneratedIds()
       .build();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     server().merge(mCustomer, options);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(5);
     assertSql(sql.get(0)).contains("select t0.id, t2.id, t1.id from mcustomer t0 left join maddress t2 on t2.id = t0.shipping_address_id left join maddress t1 on t1.id = t0.billing_address_id where t0.id = ?");
     assertSql(sql.get(1)).contains("update maddress set street=?, city=?, version=? where id=? and version=?");
@@ -119,11 +115,11 @@ public class TestMergeCustomer extends BaseTestCase {
       .setClientGeneratedIds()
       .build();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     server().merge(mCustomer, options);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(6);
     assertSql(sql.get(0)).contains("select t0.id, t2.id, t1.id from mcustomer t0 left join maddress t2 on t2.id = t0.shipping_address_id left join maddress t1 on t1.id = t0.billing_address_id where t0.id = ?");
     assertSql(sql.get(1)).contains("insert into maddress (id, street, city, version) values (?,?,?,?)");
@@ -152,11 +148,11 @@ public class TestMergeCustomer extends BaseTestCase {
       .setClientGeneratedIds() // As we are using clientIds ... we don't know if the new UUID is an insert or update without checking
       .build();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     server().merge(mCustomer, options);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(7);
     assertSql(sql.get(0)).contains("select t0.id, t2.id, t1.id from mcustomer t0 left join maddress t2 on t2.id = t0.shipping_address_id left join maddress t1 on t1.id = t0.billing_address_id where t0.id = ?");
 
@@ -175,7 +171,7 @@ public class TestMergeCustomer extends BaseTestCase {
     MCustomer c = new MCustomer("Null Address");
     c.setBillingAddress(new MAddress("Cow corner", "Mid Wicket"));
 
-    Ebean.save(c);
+    DB.save(c);
 
     MCustomer mCustomer = rebuildViaJson(c);
 
@@ -189,13 +185,13 @@ public class TestMergeCustomer extends BaseTestCase {
       .setClientGeneratedIds()
       .build();
 
-    Ebean.merge(mCustomer, options);
+    DB.merge(mCustomer, options);
 
   }
 
   private MCustomer rebuildViaJson(MCustomer input) {
-    String asJson = Ebean.json().toJson(input);
-    return Ebean.json().toBean(MCustomer.class, asJson);
+    String asJson = DB.json().toJson(input);
+    return DB.json().toBean(MCustomer.class, asJson);
   }
 
   @Test
@@ -210,10 +206,10 @@ public class TestMergeCustomer extends BaseTestCase {
       .addPath("contacts")
       .build();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     server().merge(mCustomer, options);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(20);
     }
@@ -236,10 +232,10 @@ public class TestMergeCustomer extends BaseTestCase {
       .addPath("contacts")
       .build();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     server().merge(mCustomer, options);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(20);
     }
@@ -274,10 +270,10 @@ public class TestMergeCustomer extends BaseTestCase {
       .addPath("contacts")
       .build();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     server().merge(mCustomer, options);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(16);
       assertSql(sql.get(0)).contains("select t0.id, t1.id from mcustomer t0 left join mcontact t1 on t1.customer_id = t0.id where t0.id = ?");
@@ -314,10 +310,10 @@ public class TestMergeCustomer extends BaseTestCase {
       .setDeletePermanent()
       .build();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     server().merge(cust1, options);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     if (isPersistBatchOnCascade()) {
 
       assertSql(sql.get(0)).contains("select t0.id, t3.id, t1.id, t2.id from mcustomer t0 left join maddress t3 on t3.id = t0.shipping_address_id left join maddress t1 on t1.id = t0.billing_address_id left join mcontact t2 on t2.customer_id = t0.id where t0.id = ?");
@@ -361,21 +357,21 @@ public class TestMergeCustomer extends BaseTestCase {
 
   private MCustomer partial(String name, String fetchGraph) {
     MCustomer cust1 = buildCustomer(name);
-    Ebean.save(cust1);
+    DB.save(cust1);
 
     FetchPath fetchPath = PathProperties.parse(fetchGraph);
-    String asJson = Ebean.json().toJson(cust1, fetchPath);
-    return Ebean.json().toBean(MCustomer.class, asJson);
+    String asJson = DB.json().toJson(cust1, fetchPath);
+    return DB.json().toBean(MCustomer.class, asJson);
   }
 
   private MCustomer customer(String name) {
 
     MCustomer cust1 = buildCustomer(name);
-    Ebean.save(cust1);
+    DB.save(cust1);
 
-    String asJson = Ebean.json().toJson(cust1);
+    String asJson = DB.json().toJson(cust1);
 
-    return Ebean.json().toBean(MCustomer.class, asJson);
+    return DB.json().toBean(MCustomer.class, asJson);
   }
 
   private MCustomer buildCustomer(String name) {
diff --git a/ebean-core/src/test/java/org/tests/merge/TestMergeM2M.java b/ebean-test/src/test/java/org/tests/merge/TestMergeM2M.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/merge/TestMergeM2M.java
rename to ebean-test/src/test/java/org/tests/merge/TestMergeM2M.java
index 6ad18dbec..4974bfae1 100644
--- a/ebean-core/src/test/java/org/tests/merge/TestMergeM2M.java
+++ b/ebean-test/src/test/java/org/tests/merge/TestMergeM2M.java
@@ -1,11 +1,11 @@
 package org.tests.merge;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.MergeOptions;
 import io.ebean.MergeOptionsBuilder;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -22,11 +22,11 @@ public class TestMergeM2M extends BaseTestCase {
     MGroup group4 = new MGroup(4, "gfour");
     MGroup group5 = new MGroup(5, "gfive");
 
-    Ebean.save(group1);
-    Ebean.save(group2);
-    Ebean.save(group3);
-    Ebean.save(group4);
-    Ebean.save(group5);
+    DB.save(group1);
+    DB.save(group2);
+    DB.save(group3);
+    DB.save(group4);
+    DB.save(group5);
 
     MMachine m0 = new MMachine("mac1");
     m0.getGroups().add(group1);
@@ -35,11 +35,11 @@ public class TestMergeM2M extends BaseTestCase {
 
     MergeOptions options = new MergeOptionsBuilder().addPath("groups").build();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.merge(m0, options);
+    DB.merge(m0, options);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(6);
       assertSql(sql.get(0)).contains("select");
@@ -63,9 +63,9 @@ public class TestMergeM2M extends BaseTestCase {
     m1.getGroups().add(group4);
     m1.getGroups().add(group5);
 
-    Ebean.merge(m1, options);
+    DB.merge(m1, options);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(9);
     assertSql(sql.get(0)).contains("select");
     assertSql(sql.get(1)).contains("delete from mmachine_mgroup");
diff --git a/ebean-core/src/test/java/org/tests/mockito/TestMockitoMock.java b/ebean-test/src/test/java/org/tests/mockito/TestMockitoMock.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/mockito/TestMockitoMock.java
rename to ebean-test/src/test/java/org/tests/mockito/TestMockitoMock.java
index b9222f8b6..86cb2ab2b 100644
--- a/ebean-core/src/test/java/org/tests/mockito/TestMockitoMock.java
+++ b/ebean-test/src/test/java/org/tests/mockito/TestMockitoMock.java
@@ -1,6 +1,6 @@
 package org.tests.mockito;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import org.tests.model.aggregation.DOrg;
 import org.tests.model.basic.PersistentFile;
diff --git a/ebean-core/src/test/java/org/tests/model/BaseModel.java b/ebean-test/src/test/java/org/tests/model/BaseModel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/BaseModel.java
rename to ebean-test/src/test/java/org/tests/model/BaseModel.java
diff --git a/ebean-core/src/test/java/org/tests/model/EGenProps.java b/ebean-test/src/test/java/org/tests/model/EGenProps.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/EGenProps.java
rename to ebean-test/src/test/java/org/tests/model/EGenProps.java
diff --git a/ebean-core/src/test/java/org/tests/model/EWhoProps.java b/ebean-test/src/test/java/org/tests/model/EWhoProps.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/EWhoProps.java
rename to ebean-test/src/test/java/org/tests/model/EWhoProps.java
diff --git a/ebean-core/src/test/java/org/tests/model/EWhoPropsSuper.java b/ebean-test/src/test/java/org/tests/model/EWhoPropsSuper.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/EWhoPropsSuper.java
rename to ebean-test/src/test/java/org/tests/model/EWhoPropsSuper.java
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/DMachine.java b/ebean-test/src/test/java/org/tests/model/aggregation/DMachine.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/aggregation/DMachine.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/DMachine.java
index afc915bb9..af12d5787 100644
--- a/ebean-core/src/test/java/org/tests/model/aggregation/DMachine.java
+++ b/ebean-test/src/test/java/org/tests/model/aggregation/DMachine.java
@@ -2,11 +2,7 @@ package org.tests.model.aggregation;
 
 import io.ebean.Model;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/DMachineAuxUse.java b/ebean-test/src/test/java/org/tests/model/aggregation/DMachineAuxUse.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/aggregation/DMachineAuxUse.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/DMachineAuxUse.java
index e967f3150..58eae294d 100644
--- a/ebean-core/src/test/java/org/tests/model/aggregation/DMachineAuxUse.java
+++ b/ebean-test/src/test/java/org/tests/model/aggregation/DMachineAuxUse.java
@@ -2,12 +2,7 @@ package org.tests.model.aggregation;
 
 import io.ebean.Model;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.math.BigDecimal;
 import java.time.LocalDate;
 
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/DMachineAuxUseAgg.java b/ebean-test/src/test/java/org/tests/model/aggregation/DMachineAuxUseAgg.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/aggregation/DMachineAuxUseAgg.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/DMachineAuxUseAgg.java
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/DMachineStats.java b/ebean-test/src/test/java/org/tests/model/aggregation/DMachineStats.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/aggregation/DMachineStats.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/DMachineStats.java
index 54c8eb0a4..d88df603d 100644
--- a/ebean-core/src/test/java/org/tests/model/aggregation/DMachineStats.java
+++ b/ebean-test/src/test/java/org/tests/model/aggregation/DMachineStats.java
@@ -1,11 +1,6 @@
 package org.tests.model.aggregation;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.math.BigDecimal;
 import java.time.LocalDate;
 
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/DMachineStatsAgg.java b/ebean-test/src/test/java/org/tests/model/aggregation/DMachineStatsAgg.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/aggregation/DMachineStatsAgg.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/DMachineStatsAgg.java
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/DMachineUse.java b/ebean-test/src/test/java/org/tests/model/aggregation/DMachineUse.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/aggregation/DMachineUse.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/DMachineUse.java
index d8015931f..66d3677f3 100644
--- a/ebean-core/src/test/java/org/tests/model/aggregation/DMachineUse.java
+++ b/ebean-test/src/test/java/org/tests/model/aggregation/DMachineUse.java
@@ -2,12 +2,7 @@ package org.tests.model.aggregation;
 
 import io.ebean.Model;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.math.BigDecimal;
 import java.time.LocalDate;
 
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/DOrg.java b/ebean-test/src/test/java/org/tests/model/aggregation/DOrg.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/aggregation/DOrg.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/DOrg.java
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/Decimal93.java b/ebean-test/src/test/java/org/tests/model/aggregation/Decimal93.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/aggregation/Decimal93.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/Decimal93.java
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/MachineUseData.java b/ebean-test/src/test/java/org/tests/model/aggregation/MachineUseData.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/model/aggregation/MachineUseData.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/MachineUseData.java
index 06452fdbd..4a2177d5c 100644
--- a/ebean-core/src/test/java/org/tests/model/aggregation/MachineUseData.java
+++ b/ebean-test/src/test/java/org/tests/model/aggregation/MachineUseData.java
@@ -1,6 +1,6 @@
 package org.tests.model.aggregation;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.Transactional;
 
 import java.math.BigDecimal;
@@ -11,11 +11,11 @@ public class MachineUseData {
 
   public static DOrg load() {
 
-    int count = Ebean.find(DMachineUse.class).findCount();
+    int count = DB.find(DMachineUse.class).findCount();
     if (count == 0) {
       return new MachineUseData().loadData();
     } else {
-      return Ebean.find(DOrg.class).where().eq("name", "org0").findOne();
+      return DB.find(DOrg.class).where().eq("name", "org0").findOne();
     }
   }
 
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/TestAggregationMany.java b/ebean-test/src/test/java/org/tests/model/aggregation/TestAggregationMany.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/aggregation/TestAggregationMany.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/TestAggregationMany.java
index 6c7fa4d62..9660d7530 100644
--- a/ebean-core/src/test/java/org/tests/model/aggregation/TestAggregationMany.java
+++ b/ebean-test/src/test/java/org/tests/model/aggregation/TestAggregationMany.java
@@ -2,8 +2,8 @@ package org.tests.model.aggregation;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -16,7 +16,7 @@ public class TestAggregationMany extends BaseTestCase {
 
     DOrg org = MachineUseData.load();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<DMachine> machines = DB.find(DMachine.class)
       .setDisableLazyLoading(true)
@@ -29,7 +29,7 @@ public class TestAggregationMany extends BaseTestCase {
       assertThat(machine.getMachineStats()).isEmpty();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t0.version, t0.organisation_id from dmachine t0 where t0.organisation_id = ?");
@@ -46,7 +46,7 @@ public class TestAggregationMany extends BaseTestCase {
 
     DOrg org = MachineUseData.load();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<DMachine> machines = DB.find(DMachine.class)
       .setDisableLazyLoading(true)
@@ -60,7 +60,7 @@ public class TestAggregationMany extends BaseTestCase {
       assertThat(machine.getMachineStats()).isEmpty();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t1.name, sum(t1.use_secs), sum(t1.fuel) from dmachine t0 left join d_machine_aux_use t1 on t1.machine_id = t0.id where t0.organisation_id = ? group by t0.id, t0.name, t1.name order by t0.id");
@@ -71,7 +71,7 @@ public class TestAggregationMany extends BaseTestCase {
 
     DOrg org = MachineUseData.load();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<DMachine> machines = DB.find(DMachine.class)
       .setDisableLazyLoading(true)
@@ -86,7 +86,7 @@ public class TestAggregationMany extends BaseTestCase {
       assertThat(machine.getMachineStats()).isEmpty();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, sum(t1.use_secs), sum(t1.fuel) from dmachine t0 left join d_machine_aux_use t1 on t1.machine_id = t0.id where t0.organisation_id = ? group by t0.id, t0.name order by t0.id");
diff --git a/ebean-core/src/test/java/org/tests/model/aggregation/TestAggregationTopLevel.java b/ebean-test/src/test/java/org/tests/model/aggregation/TestAggregationTopLevel.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/model/aggregation/TestAggregationTopLevel.java
rename to ebean-test/src/test/java/org/tests/model/aggregation/TestAggregationTopLevel.java
index 30ee89027..950ba1588 100644
--- a/ebean-core/src/test/java/org/tests/model/aggregation/TestAggregationTopLevel.java
+++ b/ebean-test/src/test/java/org/tests/model/aggregation/TestAggregationTopLevel.java
@@ -3,9 +3,9 @@ package org.tests.model.aggregation;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.math.BigDecimal;
 import java.time.LocalDate;
@@ -16,7 +16,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestAggregationTopLevel extends BaseTestCase {
 
-  @BeforeClass
+  @BeforeAll
   public static void setup() {
     loadData();
   }
@@ -42,11 +42,11 @@ public class TestAggregationTopLevel extends BaseTestCase {
       .having().gt("totalKms", 1)
       .query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.findCount();
     query.findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
 
     if (isH2() || isPostgres()) {
@@ -136,12 +136,12 @@ public class TestAggregationTopLevel extends BaseTestCase {
       .having().gt("sum(hours)", 2)
       .query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<DMachineStats> result = query.findList();
     assertThat(result).isNotEmpty();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select sum(t0.total_kms), sum(t0.hours), t1.id, t1.name from d_machine_stats t0 join dmachine t1 on t1.id = t0.machine_id where t0.edate > ? group by t1.id, t1.name having sum(t0.hours) > ?");
   }
@@ -156,12 +156,12 @@ public class TestAggregationTopLevel extends BaseTestCase {
       .having().gt("sum(hours)", 2)
       .query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<DMachineStats> result = query.findList();
     assertThat(result).isNotEmpty();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.edate, sum(t0.total_kms), sum(t0.hours), t1.id, t1.name from d_machine_stats t0 join dmachine t1 on t1.id = t0.machine_id where t0.edate > ? group by t0.edate, t1.id, t1.name having sum(t0.hours) > ?");  }
 
@@ -176,12 +176,12 @@ public class TestAggregationTopLevel extends BaseTestCase {
       .having().gt("sum(hours)", 2)
       .query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<DMachineStats> result = query.findList();
     assertThat(result).isNotEmpty();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
 
     assertSql(sql.get(0)).contains("select sum(t0.total_kms), sum(t0.hours), t0.machine_id from d_machine_stats t0 where t0.edate > ? group by t0.machine_id having sum(t0.hours) > ?");
@@ -198,12 +198,12 @@ public class TestAggregationTopLevel extends BaseTestCase {
       .having().gt("sum(hours)", 2)
       .query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<DMachineStats> result = query.findList();
     assertThat(result).isNotEmpty();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
 
     assertSql(sql.get(0)).contains("select t0.edate, sum(t0.total_kms), sum(t0.hours), t0.machine_id from d_machine_stats t0 where t0.edate > ? group by t0.edate, t0.machine_id having sum(t0.hours) > ?");
@@ -226,7 +226,7 @@ public class TestAggregationTopLevel extends BaseTestCase {
   @Test
   public void groupBy_in_fetchClause_singleRowInMany() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Query<DMachine> query = DB.find(DMachine.class)
       .select("name")
@@ -238,7 +238,7 @@ public class TestAggregationTopLevel extends BaseTestCase {
     assertThat(result).isNotEmpty();
     assertThat(result.get(0).getMachineStats().get(0).getTotalKms()).isNotNull();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
 
     assertThat(sqlOf(query)).contains("select t0.id, t0.name, sum(t1.total_kms) from dmachine t0 left join d_machine_stats t1 on t1.machine_id = t0.id where t0.name = ? group by t0.id, t0.name order by t0.id");
@@ -247,7 +247,7 @@ public class TestAggregationTopLevel extends BaseTestCase {
   @Test
   public void groupBy_in_fetchClause_multipleRowsInMany() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Query<DMachine> query = DB.find(DMachine.class)
       .select("name")
@@ -264,7 +264,7 @@ public class TestAggregationTopLevel extends BaseTestCase {
     assertThat(firstStat.getRate()).isNotNull();
     assertThat(firstStat.getDate()).isNotNull();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
 
     assertThat(sqlOf(query)).contains("select t0.id, t0.name, t1.edate, max(t1.rate), sum(t1.total_kms) from dmachine t0 left join d_machine_stats t1 on t1.machine_id = t0.id where t0.name = ? group by t0.id, t0.name, t1.edate order by t0.id");
diff --git a/ebean-core/src/test/java/org/tests/model/array/EArrayBean.java b/ebean-test/src/test/java/org/tests/model/array/EArrayBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/array/EArrayBean.java
rename to ebean-test/src/test/java/org/tests/model/array/EArrayBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/array/EArraySetBean.java b/ebean-test/src/test/java/org/tests/model/array/EArraySetBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/array/EArraySetBean.java
rename to ebean-test/src/test/java/org/tests/model/array/EArraySetBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/array/IntEnum.java b/ebean-test/src/test/java/org/tests/model/array/IntEnum.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/array/IntEnum.java
rename to ebean-test/src/test/java/org/tests/model/array/IntEnum.java
diff --git a/ebean-core/src/test/java/org/tests/model/array/TestDbArray_asSet.java b/ebean-test/src/test/java/org/tests/model/array/TestDbArray_asSet.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/model/array/TestDbArray_asSet.java
rename to ebean-test/src/test/java/org/tests/model/array/TestDbArray_asSet.java
index 36b917c36..0ff6f57e1 100644
--- a/ebean-core/src/test/java/org/tests/model/array/TestDbArray_asSet.java
+++ b/ebean-test/src/test/java/org/tests/model/array/TestDbArray_asSet.java
@@ -1,25 +1,21 @@
 package org.tests.model.array;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
-import java.util.HashSet;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.UUID;
+import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestDbArray_asSet extends BaseTestCase {
 
-  private EArraySetBean bean = new EArraySetBean();
+  private final EArraySetBean bean = new EArraySetBean();
 
   private EArraySetBean found;
 
@@ -51,14 +47,14 @@ public class TestDbArray_asSet extends BaseTestCase {
     status.add(EArrayBean.Status.TWO);
     bean.setStatus(status);
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    found = Ebean.find(EArraySetBean.class, bean.getId());
+    found = DB.find(EArraySetBean.class, bean.getId());
 
     assertThat(found.getPhoneNumbers()).containsExactly("4321", "9823");
 
     if (isPostgres()) {
-      Query<EArraySetBean> query = Ebean.find(EArraySetBean.class)
+      Query<EArraySetBean> query = DB.find(EArraySetBean.class)
         .where()
         .arrayContains("otherIds", 96L, 97L)
         .arrayContains("uids", first)
@@ -74,7 +70,7 @@ public class TestDbArray_asSet extends BaseTestCase {
       assertSql(query).contains(" coalesce(cardinality(t0.phone_numbers),0) <> 0");
       assertThat(list).hasSize(1);
 
-      query = Ebean.find(EArraySetBean.class)
+      query = DB.find(EArraySetBean.class)
         .where()
         .arrayIsEmpty("otherIds")
         .arrayNotContains("uids", first)
@@ -93,11 +89,11 @@ public class TestDbArray_asSet extends BaseTestCase {
   //@Test//(dependsOnMethods = "insert")
   public void json_parse_format() {
 
-    String asJson = Ebean.json().toJson(found);
+    String asJson = DB.json().toJson(found);
     assertThat(asJson).contains("\"phoneNumbers\":[\"4321\",\"9823\"]");
     assertThat(asJson).contains("\"id\":");
 
-    EArraySetBean fromJson = Ebean.json().toBean(EArraySetBean.class, asJson);
+    EArraySetBean fromJson = DB.json().toBean(EArraySetBean.class, asJson);
     assertEquals(found.getId(), fromJson.getId());
     assertEquals(found.getId(), fromJson.getId());
     assertEquals(found.getName(), fromJson.getName());
@@ -108,9 +104,9 @@ public class TestDbArray_asSet extends BaseTestCase {
   public void update_when_notDirty() {
 
     found.setName("jack");
-    LoggedSqlCollector.start();
-    Ebean.save(found);
-    List<String> sql = LoggedSqlCollector.stop();
+    LoggedSql.start();
+    DB.save(found);
+    List<String> sql = LoggedSql.stop();
 
     // we don't update the phone numbers (as they are not dirty)
     assertSql(sql.get(0)).contains("update earray_set_bean set name=?, version=? where");
@@ -122,9 +118,9 @@ public class TestDbArray_asSet extends BaseTestCase {
     found.getPhoneNumbers().add("9987");
     found.getUids().add(UUID.randomUUID());
 
-    LoggedSqlCollector.start();
-    Ebean.save(found);
-    List<String> sql = LoggedSqlCollector.stop();
+    LoggedSql.start();
+    DB.save(found);
+    List<String> sql = LoggedSql.stop();
 
     assertSql(sql.get(0)).contains("update earray_set_bean set phone_numbers=?, uids=?, version=? where");
   }
@@ -139,8 +135,8 @@ public class TestDbArray_asSet extends BaseTestCase {
     bean.setOtherIds(null);
     bean.setUids(null);
 
-    Ebean.save(bean);
-    Ebean.delete(bean);
+    DB.save(bean);
+    DB.delete(bean);
   }
 
   @Test
@@ -156,8 +152,8 @@ public class TestDbArray_asSet extends BaseTestCase {
     Set<EArraySetBean> all = new HashSet<>();
     all.add(bean);
 
-    Ebean.saveAll(all);
-    Ebean.deleteAll(all);
+    DB.saveAll(all);
+    DB.deleteAll(all);
   }
 
   @Test
@@ -177,13 +173,15 @@ public class TestDbArray_asSet extends BaseTestCase {
     bean.setUids(uids);
     bean.setStatus(statuses);
 
-    Ebean.save(bean);
+    DB.save(bean);
     // load cache
-    Ebean.find(EArraySetBean.class, bean.getId());
-    // hit cache
-    EArraySetBean found = Ebean.find(EArraySetBean.class, bean.getId());
+    final EArraySetBean entry = DB.find(EArraySetBean.class, bean.getId());
+    assertThat(entry.getUids()).hasSameElementsAs(uids);
+    assertThat(entry.getStatus()).hasSameElementsAs(statuses);
 
-    assertThat(found.getUids()).isEqualTo(uids);
-    assertThat(found.getStatus()).isEqualTo(statuses);
+    // hit cache
+    EArraySetBean found = DB.find(EArraySetBean.class, bean.getId());
+    assertThat(found.getUids()).hasSameElementsAs(uids);
+    assertThat(found.getStatus()).hasSameElementsAs(statuses);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/array/TestDbArray_basic.java b/ebean-test/src/test/java/org/tests/model/array/TestDbArray_basic.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/model/array/TestDbArray_basic.java
rename to ebean-test/src/test/java/org/tests/model/array/TestDbArray_basic.java
index a3b5ad3d0..69328ce15 100644
--- a/ebean-core/src/test/java/org/tests/model/array/TestDbArray_basic.java
+++ b/ebean-test/src/test/java/org/tests/model/array/TestDbArray_basic.java
@@ -7,19 +7,15 @@ import io.ebean.SqlRow;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.UUID;
+import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestDbArray_basic extends BaseTestCase {
 
@@ -142,9 +138,9 @@ public class TestDbArray_basic extends BaseTestCase {
   public void update_when_notDirty() {
 
     found.setName("jack");
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.save(found);
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     // we don't update the phone numbers (as they are not dirty)
     assertSql(sql.get(0)).contains("update earray_bean set name=?, version=? where");
@@ -156,9 +152,9 @@ public class TestDbArray_basic extends BaseTestCase {
     found.getPhoneNumbers().add("9987");
     found.getUids().add(UUID.randomUUID());
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.save(found);
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertSql(sql.get(0)).contains("update earray_bean set phone_numbers=?, uids=?, version=? where");
   }
@@ -268,11 +264,12 @@ public class TestDbArray_basic extends BaseTestCase {
 
     DB.save(bean);
     // load cache
-    DB.find(EArrayBean.class, bean.getId());
+    final EArrayBean entry = DB.find(EArrayBean.class, bean.getId());
+    assertThat(entry.getUids()).hasSameElementsAs(uids);
+    assertThat(entry.getStatuses()).hasSameElementsAs(statuses);
     // hit cache
     EArrayBean found = DB.find(EArrayBean.class, bean.getId());
-
-    assertThat(found.getUids()).isEqualTo(uids);
-    assertThat(found.getStatuses()).isEqualTo(statuses);
+    assertThat(found.getUids()).hasSameElementsAs(uids);
+    assertThat(found.getStatuses()).hasSameElementsAs(statuses);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/array/VarcharEnum.java b/ebean-test/src/test/java/org/tests/model/array/VarcharEnum.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/array/VarcharEnum.java
rename to ebean-test/src/test/java/org/tests/model/array/VarcharEnum.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Address.java b/ebean-test/src/test/java/org/tests/model/basic/Address.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/model/basic/Address.java
rename to ebean-test/src/test/java/org/tests/model/basic/Address.java
index 3b68776bd..98234699a 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Address.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Address.java
@@ -3,12 +3,7 @@ package org.tests.model.basic;
 import io.ebean.annotation.InvalidateQueryCache;
 import org.tests.model.basic.metaannotation.SizeMedium;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
 import java.sql.Timestamp;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Animal.java b/ebean-test/src/test/java/org/tests/model/basic/Animal.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/model/basic/Animal.java
rename to ebean-test/src/test/java/org/tests/model/basic/Animal.java
index 62e893506..069b1e4cf 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Animal.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Animal.java
@@ -1,13 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.Column;
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.ManyToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
diff --git a/ebean-core/src/test/java/org/tests/model/basic/AnimalShelter.java b/ebean-test/src/test/java/org/tests/model/basic/AnimalShelter.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/AnimalShelter.java
rename to ebean-test/src/test/java/org/tests/model/basic/AnimalShelter.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Article.java b/ebean-test/src/test/java/org/tests/model/basic/Article.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/Article.java
rename to ebean-test/src/test/java/org/tests/model/basic/Article.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Attribute.java b/ebean-test/src/test/java/org/tests/model/basic/Attribute.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/model/basic/Attribute.java
rename to ebean-test/src/test/java/org/tests/model/basic/Attribute.java
index 49efb2b6e..d660c93f0 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Attribute.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Attribute.java
@@ -1,11 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.Inheritance;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 
 @Entity
 @Inheritance()
diff --git a/ebean-core/src/test/java/org/tests/model/basic/AttributeHolder.java b/ebean-test/src/test/java/org/tests/model/basic/AttributeHolder.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/AttributeHolder.java
rename to ebean-test/src/test/java/org/tests/model/basic/AttributeHolder.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/BBookmark.java b/ebean-test/src/test/java/org/tests/model/basic/BBookmark.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/model/basic/BBookmark.java
rename to ebean-test/src/test/java/org/tests/model/basic/BBookmark.java
index 3e18cb56d..9cc71440d 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/BBookmark.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/BBookmark.java
@@ -1,11 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 
 /**
  * A user may have multiple bookmarks
diff --git a/ebean-core/src/test/java/org/tests/model/basic/BBookmarkOrg.java b/ebean-test/src/test/java/org/tests/model/basic/BBookmarkOrg.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/BBookmarkOrg.java
rename to ebean-test/src/test/java/org/tests/model/basic/BBookmarkOrg.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/BBookmarkUser.java b/ebean-test/src/test/java/org/tests/model/basic/BBookmarkUser.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/BBookmarkUser.java
rename to ebean-test/src/test/java/org/tests/model/basic/BBookmarkUser.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/BWithQIdent.java b/ebean-test/src/test/java/org/tests/model/basic/BWithQIdent.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/BWithQIdent.java
rename to ebean-test/src/test/java/org/tests/model/basic/BWithQIdent.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/BasicDomain.java b/ebean-test/src/test/java/org/tests/model/basic/BasicDomain.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/BasicDomain.java
rename to ebean-test/src/test/java/org/tests/model/basic/BasicDomain.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/BeanWithTimeZone.java b/ebean-test/src/test/java/org/tests/model/basic/BeanWithTimeZone.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/BeanWithTimeZone.java
rename to ebean-test/src/test/java/org/tests/model/basic/BeanWithTimeZone.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/BigDog.java b/ebean-test/src/test/java/org/tests/model/basic/BigDog.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/BigDog.java
rename to ebean-test/src/test/java/org/tests/model/basic/BigDog.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/CKeyAssoc.java b/ebean-test/src/test/java/org/tests/model/basic/CKeyAssoc.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/CKeyAssoc.java
rename to ebean-test/src/test/java/org/tests/model/basic/CKeyAssoc.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/CKeyDetail.java b/ebean-test/src/test/java/org/tests/model/basic/CKeyDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/CKeyDetail.java
rename to ebean-test/src/test/java/org/tests/model/basic/CKeyDetail.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/CKeyParent.java b/ebean-test/src/test/java/org/tests/model/basic/CKeyParent.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/basic/CKeyParent.java
rename to ebean-test/src/test/java/org/tests/model/basic/CKeyParent.java
index 36ef22ab8..1b1cb0a81 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/CKeyParent.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/CKeyParent.java
@@ -2,12 +2,7 @@ package org.tests.model.basic;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.CascadeType;
-import javax.persistence.EmbeddedId;
-import javax.persistence.Entity;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/CKeyParentId.java b/ebean-test/src/test/java/org/tests/model/basic/CKeyParentId.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/CKeyParentId.java
rename to ebean-test/src/test/java/org/tests/model/basic/CKeyParentId.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Car.java b/ebean-test/src/test/java/org/tests/model/basic/Car.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/basic/Car.java
rename to ebean-test/src/test/java/org/tests/model/basic/Car.java
index 9bf17245e..268920a34 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Car.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Car.java
@@ -2,13 +2,7 @@ package org.tests.model.basic;
 
 import io.ebean.annotation.DbEnumValue;
 
-import javax.persistence.Column;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.Inheritance;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderBy;
+import javax.persistence.*;
 import java.util.HashSet;
 import java.util.Set;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/CarAccessory.java b/ebean-test/src/test/java/org/tests/model/basic/CarAccessory.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/CarAccessory.java
rename to ebean-test/src/test/java/org/tests/model/basic/CarAccessory.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/CarFuse.java b/ebean-test/src/test/java/org/tests/model/basic/CarFuse.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/CarFuse.java
rename to ebean-test/src/test/java/org/tests/model/basic/CarFuse.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Cat.java b/ebean-test/src/test/java/org/tests/model/basic/Cat.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/Cat.java
rename to ebean-test/src/test/java/org/tests/model/basic/Cat.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Contact.java b/ebean-test/src/test/java/org/tests/model/basic/Contact.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/basic/Contact.java
rename to ebean-test/src/test/java/org/tests/model/basic/Contact.java
index 4612fbf14..883d27d5c 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Contact.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Contact.java
@@ -1,21 +1,10 @@
 package org.tests.model.basic;
 
-import io.ebean.annotation.Cache;
-import io.ebean.annotation.ChangeLog;
-import io.ebean.annotation.CreatedTimestamp;
-import io.ebean.annotation.DocEmbedded;
-import io.ebean.annotation.DocStore;
 import io.ebean.annotation.Index;
+import io.ebean.annotation.*;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
-
 import java.sql.Timestamp;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ContactGroup.java b/ebean-test/src/test/java/org/tests/model/basic/ContactGroup.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/ContactGroup.java
rename to ebean-test/src/test/java/org/tests/model/basic/ContactGroup.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ContactNote.java b/ebean-test/src/test/java/org/tests/model/basic/ContactNote.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/ContactNote.java
rename to ebean-test/src/test/java/org/tests/model/basic/ContactNote.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Country.java b/ebean-test/src/test/java/org/tests/model/basic/Country.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/model/basic/Country.java
rename to ebean-test/src/test/java/org/tests/model/basic/Country.java
index c2de046f1..bde38fc78 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Country.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Country.java
@@ -1,11 +1,6 @@
 package org.tests.model.basic;
 
-import io.ebean.annotation.Cache;
-import io.ebean.annotation.CacheBeanTuning;
-import io.ebean.annotation.ChangeLog;
-import io.ebean.annotation.ChangeLogInsertMode;
-import io.ebean.annotation.DocStore;
-import io.ebean.annotation.ReadAudit;
+import io.ebean.annotation.*;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Customer.java b/ebean-test/src/test/java/org/tests/model/basic/Customer.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/basic/Customer.java
rename to ebean-test/src/test/java/org/tests/model/basic/Customer.java
index 4f8c7d206..0b4f98539 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Customer.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Customer.java
@@ -1,24 +1,9 @@
 package org.tests.model.basic;
 
-import io.ebean.annotation.Cache;
-import io.ebean.annotation.ChangeLog;
-import io.ebean.annotation.ChangeLogInsertMode;
-import io.ebean.annotation.DbComment;
-import io.ebean.annotation.DbEnumValue;
-import io.ebean.annotation.DocEmbedded;
-import io.ebean.annotation.DocStore;
-import io.ebean.annotation.JsonIgnore;
-import io.ebean.annotation.Where;
+import io.ebean.annotation.*;
 import org.tests.model.basic.finder.CustomerFinder;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.ManyToOne;
-import javax.persistence.NamedQueries;
-import javax.persistence.NamedQuery;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Transient;
+import javax.persistence.*;
 import javax.validation.constraints.NotNull;
 import javax.validation.constraints.Size;
 import java.sql.Date;
diff --git a/ebean-core/src/test/java/org/tests/model/basic/CustomerAggregate.java b/ebean-test/src/test/java/org/tests/model/basic/CustomerAggregate.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/CustomerAggregate.java
rename to ebean-test/src/test/java/org/tests/model/basic/CustomerAggregate.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Dog.java b/ebean-test/src/test/java/org/tests/model/basic/Dog.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/Dog.java
rename to ebean-test/src/test/java/org/tests/model/basic/Dog.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasic.java b/ebean-test/src/test/java/org/tests/model/basic/EBasic.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasic.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasic.java
index 278328f92..603102032 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/EBasic.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/EBasic.java
@@ -7,7 +7,6 @@ import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 import javax.validation.constraints.Size;
-
 import java.sql.Timestamp;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicChangeLog.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicChangeLog.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicChangeLog.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicChangeLog.java
index 0ac02e749..214a2447f 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/EBasicChangeLog.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/EBasicChangeLog.java
@@ -1,25 +1,16 @@
 package org.tests.model.basic;
 
-import io.ebean.annotation.Cache;
-import io.ebean.annotation.ChangeLog;
-import io.ebean.annotation.DbJson;
-import io.ebean.annotation.ReadAudit;
-import io.ebean.annotation.WhenCreated;
-import io.ebean.annotation.WhenModified;
-import io.ebean.annotation.WhoCreated;
-import io.ebean.annotation.WhoModified;
+import io.ebean.annotation.*;
+import org.tests.model.json.PlainBean;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Version;
 import javax.validation.constraints.Size;
-
-import org.tests.model.json.PlainBean;
+import java.sql.Timestamp;
 
 import static io.ebean.annotation.MutationDetection.SOURCE;
 
-import java.sql.Timestamp;
-
 @Cache(enableQueryCache = true)
 @ReadAudit
 @ChangeLog(updatesThatInclude = {"name", "shortDescription", "plainBean"})
@@ -52,7 +43,7 @@ public class EBasicChangeLog {
 
   @Version
   Long version;
-  
+
   @DbJson(length = 500, mutationDetection = SOURCE) // such that we can rebuild old values
   PlainBean plainBean;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicClob.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicClob.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicClob.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicClob.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicClobFetchEager.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicClobFetchEager.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicClobFetchEager.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicClobFetchEager.java
index b95d56bf8..4ae5a6b1d 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/EBasicClobFetchEager.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/EBasicClobFetchEager.java
@@ -1,11 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.Basic;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.Lob;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.sql.Timestamp;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicClobNoVer.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicClobNoVer.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicClobNoVer.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicClobNoVer.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicEncrypt.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicEncrypt.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicEncrypt.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicEncrypt.java
index 31cbcab7a..3fb5cc9e4 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/EBasicEncrypt.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/EBasicEncrypt.java
@@ -2,11 +2,7 @@ package org.tests.model.basic;
 
 import io.ebean.annotation.Encrypted;
 
-import javax.persistence.Entity;
-import javax.persistence.EnumType;
-import javax.persistence.Enumerated;
-import javax.persistence.Id;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.sql.Date;
 import java.sql.Timestamp;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicEncryptBinary.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicEncryptBinary.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicEncryptBinary.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicEncryptBinary.java
index bd13f97e2..77c6b2f2b 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/EBasicEncryptBinary.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/EBasicEncryptBinary.java
@@ -2,11 +2,7 @@ package org.tests.model.basic;
 
 import io.ebean.annotation.Encrypted;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Lob;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.sql.Timestamp;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicEncryptClient.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicEncryptClient.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicEncryptClient.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicEncryptClient.java
index 64426c075..f77af37f5 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/EBasicEncryptClient.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/EBasicEncryptClient.java
@@ -2,12 +2,7 @@ package org.tests.model.basic;
 
 import io.ebean.annotation.Encrypted;
 
-import javax.persistence.Entity;
-import javax.persistence.EnumType;
-import javax.persistence.Enumerated;
-import javax.persistence.Id;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.time.LocalDate;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicEncryptRelate.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicEncryptRelate.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicEncryptRelate.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicEncryptRelate.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicEnumId.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicEnumId.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicEnumId.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicEnumId.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicEnumInt.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicEnumInt.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicEnumInt.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicEnumInt.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicLog.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicLog.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicLog.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicLog.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicNoDefaultConstructor.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicNoDefaultConstructor.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicNoDefaultConstructor.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicNoDefaultConstructor.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicVer.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicVer.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicVer.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicVer.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicWithLifecycle.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicWithLifecycle.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicWithLifecycle.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicWithLifecycle.java
index f375b9823..44902ed31 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/EBasicWithLifecycle.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/EBasicWithLifecycle.java
@@ -6,17 +6,7 @@ import io.ebean.annotation.PreSoftDelete;
 import io.ebean.annotation.SoftDelete;
 
 import javax.annotation.PostConstruct;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.PostLoad;
-import javax.persistence.PostPersist;
-import javax.persistence.PostRemove;
-import javax.persistence.PostUpdate;
-import javax.persistence.PrePersist;
-import javax.persistence.PreRemove;
-import javax.persistence.PreUpdate;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "e_basic_withlife")
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicWithLifecycleExceptions.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicWithLifecycleExceptions.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicWithLifecycleExceptions.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicWithLifecycleExceptions.java
index 76c1f00f0..e5df815e9 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/EBasicWithLifecycleExceptions.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/EBasicWithLifecycleExceptions.java
@@ -5,17 +5,7 @@ import io.ebean.annotation.PreSoftDelete;
 import io.ebean.annotation.SoftDelete;
 
 import javax.annotation.PostConstruct;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.PostLoad;
-import javax.persistence.PostPersist;
-import javax.persistence.PostRemove;
-import javax.persistence.PostUpdate;
-import javax.persistence.PrePersist;
-import javax.persistence.PreRemove;
-import javax.persistence.PreUpdate;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "e_basic_with_ex")
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicWithLog.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicWithLog.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicWithLog.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicWithLog.java
index 3ff7634f0..eee062e94 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/EBasicWithLog.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/EBasicWithLog.java
@@ -6,17 +6,7 @@ import io.ebean.annotation.PreSoftDelete;
 import io.ebean.annotation.SoftDelete;
 
 import javax.annotation.PostConstruct;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.PostLoad;
-import javax.persistence.PostPersist;
-import javax.persistence.PostRemove;
-import javax.persistence.PostUpdate;
-import javax.persistence.PrePersist;
-import javax.persistence.PreRemove;
-import javax.persistence.PreUpdate;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "e_basic_withlog")
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EBasicWithUniqueCon.java b/ebean-test/src/test/java/org/tests/model/basic/EBasicWithUniqueCon.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/basic/EBasicWithUniqueCon.java
rename to ebean-test/src/test/java/org/tests/model/basic/EBasicWithUniqueCon.java
index 4766414dc..20a1326b2 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/EBasicWithUniqueCon.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/EBasicWithUniqueCon.java
@@ -1,13 +1,7 @@
 package org.tests.model.basic;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Table;
-import javax.persistence.UniqueConstraint;
-import javax.persistence.Version;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
-
 import java.sql.Timestamp;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ECustomId.java b/ebean-test/src/test/java/org/tests/model/basic/ECustomId.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/ECustomId.java
rename to ebean-test/src/test/java/org/tests/model/basic/ECustomId.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EDefaultProp.java b/ebean-test/src/test/java/org/tests/model/basic/EDefaultProp.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EDefaultProp.java
rename to ebean-test/src/test/java/org/tests/model/basic/EDefaultProp.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ENullCollection.java b/ebean-test/src/test/java/org/tests/model/basic/ENullCollection.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/ENullCollection.java
rename to ebean-test/src/test/java/org/tests/model/basic/ENullCollection.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ENullCollectionDetail.java b/ebean-test/src/test/java/org/tests/model/basic/ENullCollectionDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/ENullCollectionDetail.java
rename to ebean-test/src/test/java/org/tests/model/basic/ENullCollectionDetail.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EOptOneA.java b/ebean-test/src/test/java/org/tests/model/basic/EOptOneA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EOptOneA.java
rename to ebean-test/src/test/java/org/tests/model/basic/EOptOneA.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EOptOneB.java b/ebean-test/src/test/java/org/tests/model/basic/EOptOneB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EOptOneB.java
rename to ebean-test/src/test/java/org/tests/model/basic/EOptOneB.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EOptOneC.java b/ebean-test/src/test/java/org/tests/model/basic/EOptOneC.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EOptOneC.java
rename to ebean-test/src/test/java/org/tests/model/basic/EOptOneC.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ESimple.java b/ebean-test/src/test/java/org/tests/model/basic/ESimple.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/model/basic/ESimple.java
rename to ebean-test/src/test/java/org/tests/model/basic/ESimple.java
index fdf1aa9e5..a827bc5b4 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/ESimple.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/ESimple.java
@@ -1,10 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
+import javax.persistence.*;
 
 @Entity
 public class ESimple {
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ESomeType.java b/ebean-test/src/test/java/org/tests/model/basic/ESomeType.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/ESomeType.java
rename to ebean-test/src/test/java/org/tests/model/basic/ESomeType.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ETransMany.java b/ebean-test/src/test/java/org/tests/model/basic/ETransMany.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/ETransMany.java
rename to ebean-test/src/test/java/org/tests/model/basic/ETransMany.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EVanillaCollection.java b/ebean-test/src/test/java/org/tests/model/basic/EVanillaCollection.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EVanillaCollection.java
rename to ebean-test/src/test/java/org/tests/model/basic/EVanillaCollection.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EVanillaCollectionDetail.java b/ebean-test/src/test/java/org/tests/model/basic/EVanillaCollectionDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EVanillaCollectionDetail.java
rename to ebean-test/src/test/java/org/tests/model/basic/EVanillaCollectionDetail.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/EWithInetAddr.java b/ebean-test/src/test/java/org/tests/model/basic/EWithInetAddr.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/EWithInetAddr.java
rename to ebean-test/src/test/java/org/tests/model/basic/EWithInetAddr.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/FeatureDescription.java b/ebean-test/src/test/java/org/tests/model/basic/FeatureDescription.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/FeatureDescription.java
rename to ebean-test/src/test/java/org/tests/model/basic/FeatureDescription.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/L2CachedLazyDirtFlagResetBean.java b/ebean-test/src/test/java/org/tests/model/basic/L2CachedLazyDirtFlagResetBean.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/basic/L2CachedLazyDirtFlagResetBean.java
rename to ebean-test/src/test/java/org/tests/model/basic/L2CachedLazyDirtFlagResetBean.java
index 5d9c1aeee..3f426696d 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/L2CachedLazyDirtFlagResetBean.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/L2CachedLazyDirtFlagResetBean.java
@@ -1,6 +1,7 @@
 package org.tests.model.basic;
 
 import io.ebean.annotation.Cache;
+
 import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
diff --git a/ebean-core/src/test/java/org/tests/model/basic/L2CachedLazyDirtFlagResetBeanChild.java b/ebean-test/src/test/java/org/tests/model/basic/L2CachedLazyDirtFlagResetBeanChild.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/L2CachedLazyDirtFlagResetBeanChild.java
rename to ebean-test/src/test/java/org/tests/model/basic/L2CachedLazyDirtFlagResetBeanChild.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ListAttribute.java b/ebean-test/src/test/java/org/tests/model/basic/ListAttribute.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/ListAttribute.java
rename to ebean-test/src/test/java/org/tests/model/basic/ListAttribute.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ListAttributeValue.java b/ebean-test/src/test/java/org/tests/model/basic/ListAttributeValue.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/ListAttributeValue.java
rename to ebean-test/src/test/java/org/tests/model/basic/ListAttributeValue.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MNonEnum.java b/ebean-test/src/test/java/org/tests/model/basic/MNonEnum.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/MNonEnum.java
rename to ebean-test/src/test/java/org/tests/model/basic/MNonEnum.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MNonUpdPropEntity.java b/ebean-test/src/test/java/org/tests/model/basic/MNonUpdPropEntity.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/model/basic/MNonUpdPropEntity.java
rename to ebean-test/src/test/java/org/tests/model/basic/MNonUpdPropEntity.java
index bae5aa6dc..3e6ebfaec 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/MNonUpdPropEntity.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/MNonUpdPropEntity.java
@@ -1,11 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.EnumType;
-import javax.persistence.Enumerated;
-import javax.persistence.Id;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "non_updateprop")
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MProtectedConstructBean.java b/ebean-test/src/test/java/org/tests/model/basic/MProtectedConstructBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/MProtectedConstructBean.java
rename to ebean-test/src/test/java/org/tests/model/basic/MProtectedConstructBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MRole.java b/ebean-test/src/test/java/org/tests/model/basic/MRole.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/basic/MRole.java
rename to ebean-test/src/test/java/org/tests/model/basic/MRole.java
index 280a91ce0..c66a1db60 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/MRole.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/MRole.java
@@ -1,10 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MUser.java b/ebean-test/src/test/java/org/tests/model/basic/MUser.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/basic/MUser.java
rename to ebean-test/src/test/java/org/tests/model/basic/MUser.java
index a2e1a701c..7abf2ec60 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/MUser.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/MUser.java
@@ -1,11 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToMany;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MUserType.java b/ebean-test/src/test/java/org/tests/model/basic/MUserType.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/MUserType.java
rename to ebean-test/src/test/java/org/tests/model/basic/MUserType.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MnocRole.java b/ebean-test/src/test/java/org/tests/model/basic/MnocRole.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/MnocRole.java
rename to ebean-test/src/test/java/org/tests/model/basic/MnocRole.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MnocUser.java b/ebean-test/src/test/java/org/tests/model/basic/MnocUser.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/basic/MnocUser.java
rename to ebean-test/src/test/java/org/tests/model/basic/MnocUser.java
index f34eb753d..aa71e9497 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/MnocUser.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/MnocUser.java
@@ -1,11 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToMany;
-import javax.persistence.OrderBy;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MyAdHoc.java b/ebean-test/src/test/java/org/tests/model/basic/MyAdHoc.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/MyAdHoc.java
rename to ebean-test/src/test/java/org/tests/model/basic/MyAdHoc.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MyEBasicConfigStartup.java b/ebean-test/src/test/java/org/tests/model/basic/MyEBasicConfigStartup.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/MyEBasicConfigStartup.java
rename to ebean-test/src/test/java/org/tests/model/basic/MyEBasicConfigStartup.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MyLobSize.java b/ebean-test/src/test/java/org/tests/model/basic/MyLobSize.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/basic/MyLobSize.java
rename to ebean-test/src/test/java/org/tests/model/basic/MyLobSize.java
index d189decb2..df731191e 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/MyLobSize.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/MyLobSize.java
@@ -1,11 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.Basic;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.Lob;
-import javax.persistence.OneToMany;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/MyLobSizeJoinMany.java b/ebean-test/src/test/java/org/tests/model/basic/MyLobSizeJoinMany.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/basic/MyLobSizeJoinMany.java
rename to ebean-test/src/test/java/org/tests/model/basic/MyLobSizeJoinMany.java
index 10c1bc385..2534a6ebf 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/MyLobSizeJoinMany.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/MyLobSizeJoinMany.java
@@ -1,10 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.Basic;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 
 @Entity
 public class MyLobSizeJoinMany {
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OBeanChild.java b/ebean-test/src/test/java/org/tests/model/basic/OBeanChild.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/OBeanChild.java
rename to ebean-test/src/test/java/org/tests/model/basic/OBeanChild.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OCachedBean.java b/ebean-test/src/test/java/org/tests/model/basic/OCachedBean.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/basic/OCachedBean.java
rename to ebean-test/src/test/java/org/tests/model/basic/OCachedBean.java
index 7879b5251..abe945bb5 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/OCachedBean.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/OCachedBean.java
@@ -2,12 +2,7 @@ package org.tests.model.basic;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToMany;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OCachedBeanChild.java b/ebean-test/src/test/java/org/tests/model/basic/OCachedBeanChild.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/OCachedBeanChild.java
rename to ebean-test/src/test/java/org/tests/model/basic/OCachedBeanChild.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OCachedInhChildA.java b/ebean-test/src/test/java/org/tests/model/basic/OCachedInhChildA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/OCachedInhChildA.java
rename to ebean-test/src/test/java/org/tests/model/basic/OCachedInhChildA.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OCachedInhChildB.java b/ebean-test/src/test/java/org/tests/model/basic/OCachedInhChildB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/OCachedInhChildB.java
rename to ebean-test/src/test/java/org/tests/model/basic/OCachedInhChildB.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OCachedInhRoot.java b/ebean-test/src/test/java/org/tests/model/basic/OCachedInhRoot.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/OCachedInhRoot.java
rename to ebean-test/src/test/java/org/tests/model/basic/OCachedInhRoot.java
index 1027070cc..ef6acaec8 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/OCachedInhRoot.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/OCachedInhRoot.java
@@ -1,12 +1,12 @@
 package org.tests.model.basic;
 
+import io.ebean.annotation.Cache;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Inheritance;
 import javax.persistence.Table;
 
-import io.ebean.annotation.Cache;
-
 /**
  * Cached entity for inheritance.
  *
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OCar.java b/ebean-test/src/test/java/org/tests/model/basic/OCar.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/OCar.java
rename to ebean-test/src/test/java/org/tests/model/basic/OCar.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OEngine.java b/ebean-test/src/test/java/org/tests/model/basic/OEngine.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/basic/OEngine.java
rename to ebean-test/src/test/java/org/tests/model/basic/OEngine.java
index fc3a4cc8f..cb239a007 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/OEngine.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/OEngine.java
@@ -4,7 +4,6 @@ import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.OneToOne;
 import javax.persistence.Version;
-
 import java.io.Serializable;
 import java.util.UUID;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OGearBox.java b/ebean-test/src/test/java/org/tests/model/basic/OGearBox.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/basic/OGearBox.java
rename to ebean-test/src/test/java/org/tests/model/basic/OGearBox.java
index 955807fab..9f758cf21 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/OGearBox.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/OGearBox.java
@@ -1,11 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Version;
-
+import javax.persistence.*;
 import java.io.Serializable;
 import java.util.UUID;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Order.java b/ebean-test/src/test/java/org/tests/model/basic/Order.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/basic/Order.java
rename to ebean-test/src/test/java/org/tests/model/basic/Order.java
index cea0a6e00..dfb9f2aef 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Order.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Order.java
@@ -1,26 +1,8 @@
 package org.tests.model.basic;
 
-import io.ebean.annotation.Cache;
-import io.ebean.annotation.ChangeLog;
-import io.ebean.annotation.DocEmbedded;
-import io.ebean.annotation.DocStore;
-import io.ebean.annotation.Formula;
-import io.ebean.annotation.WhenCreated;
-import io.ebean.annotation.Where;
+import io.ebean.annotation.*;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.EnumType;
-import javax.persistence.Enumerated;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderBy;
-import javax.persistence.Table;
-import javax.persistence.Transient;
-import javax.persistence.Version;
+import javax.persistence.*;
 import javax.validation.constraints.NotNull;
 import java.io.Serializable;
 import java.sql.Date;
@@ -31,7 +13,6 @@ import java.util.List;
 /**
  * Order entity bean.
  */
-@Cache
 @DocStore
 @ChangeLog
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OrderAggregate.java b/ebean-test/src/test/java/org/tests/model/basic/OrderAggregate.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/OrderAggregate.java
rename to ebean-test/src/test/java/org/tests/model/basic/OrderAggregate.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OrderDetail.java b/ebean-test/src/test/java/org/tests/model/basic/OrderDetail.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/model/basic/OrderDetail.java
rename to ebean-test/src/test/java/org/tests/model/basic/OrderDetail.java
index 8d4060cc6..6face7896 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/OrderDetail.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/OrderDetail.java
@@ -3,11 +3,7 @@ package org.tests.model.basic;
 import io.ebean.annotation.Cache;
 import io.ebean.annotation.DocEmbedded;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.io.Serializable;
 import java.sql.Timestamp;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/OrderShipment.java b/ebean-test/src/test/java/org/tests/model/basic/OrderShipment.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/OrderShipment.java
rename to ebean-test/src/test/java/org/tests/model/basic/OrderShipment.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/PFile.java b/ebean-test/src/test/java/org/tests/model/basic/PFile.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/PFile.java
rename to ebean-test/src/test/java/org/tests/model/basic/PFile.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/PFileContent.java b/ebean-test/src/test/java/org/tests/model/basic/PFileContent.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/PFileContent.java
rename to ebean-test/src/test/java/org/tests/model/basic/PFileContent.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/PersistentFile.java b/ebean-test/src/test/java/org/tests/model/basic/PersistentFile.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/PersistentFile.java
rename to ebean-test/src/test/java/org/tests/model/basic/PersistentFile.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/PersistentFileContent.java b/ebean-test/src/test/java/org/tests/model/basic/PersistentFileContent.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/PersistentFileContent.java
rename to ebean-test/src/test/java/org/tests/model/basic/PersistentFileContent.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Person.java b/ebean-test/src/test/java/org/tests/model/basic/Person.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/basic/Person.java
rename to ebean-test/src/test/java/org/tests/model/basic/Person.java
index 39496a703..d58d0f681 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Person.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Person.java
@@ -1,14 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.SequenceGenerator;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.io.Serializable;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Phone.java b/ebean-test/src/test/java/org/tests/model/basic/Phone.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/model/basic/Phone.java
rename to ebean-test/src/test/java/org/tests/model/basic/Phone.java
index 3ba7b3ebe..736e748af 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Phone.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Phone.java
@@ -1,14 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 import javax.validation.constraints.NotNull;
 import java.io.Serializable;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Product.java b/ebean-test/src/test/java/org/tests/model/basic/Product.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/basic/Product.java
rename to ebean-test/src/test/java/org/tests/model/basic/Product.java
index 30f5b62b1..60f73475c 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Product.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Product.java
@@ -1,10 +1,6 @@
 package org.tests.model.basic;
 
-import io.ebean.annotation.Cache;
-import io.ebean.annotation.CacheQueryTuning;
-import io.ebean.annotation.CreatedTimestamp;
-import io.ebean.annotation.DocStore;
-import io.ebean.annotation.Identity;
+import io.ebean.annotation.*;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ResetBasicData.java b/ebean-test/src/test/java/org/tests/model/basic/ResetBasicData.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/model/basic/ResetBasicData.java
rename to ebean-test/src/test/java/org/tests/model/basic/ResetBasicData.java
index 084f4bf08..6a01db649 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/ResetBasicData.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/ResetBasicData.java
@@ -1,7 +1,7 @@
 package org.tests.model.basic;
 
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import org.tests.model.basic.Order.Status;
 
 import java.sql.Date;
@@ -12,7 +12,7 @@ public class ResetBasicData {
 
   private static boolean runOnce;
 
-  private static EbeanServer server = Ebean.getServer(null);
+  private static Database server = DB.getDefault();
 
   public static synchronized void reset() {
 
@@ -57,7 +57,7 @@ public class ResetBasicData {
 
 
   public void deleteAll() {
-    Ebean.execute(() -> {
+    DB.execute(() -> {
 
       // orm update use bean name and bean properties
       server.sqlUpdate("delete from o_cached_bean_child").execute();
@@ -134,7 +134,7 @@ public class ResetBasicData {
 
   public void insertTestCustAndOrders() {
 
-    Ebean.execute(() -> {
+    DB.execute(() -> {
       Customer cust1 = insertCustomer("Rob");
       Customer cust2 = insertCustomerNoAddress();
       insertCustomerFiona();
@@ -173,7 +173,7 @@ public class ResetBasicData {
     c.addContact(createContact("Fiona", "Black"));
     c.addContact(createContact("Tracy", "Red"));
 
-    Ebean.save(c);
+    DB.save(c);
     return c;
   }
 
@@ -190,7 +190,7 @@ public class ResetBasicData {
     c.setName(name);
     c.setStatus(Customer.Status.ACTIVE);
 
-    Ebean.save(c);
+    DB.save(c);
     return c;
   }
 
@@ -201,13 +201,13 @@ public class ResetBasicData {
     c.setStatus(Customer.Status.NEW);
     c.addContact(createContact("Jack", "Black"));
 
-    Ebean.save(c);
+    DB.save(c);
     return c;
   }
 
   private static Customer insertCustomer(String name) {
     Customer c = createCustomer(name, "1 Banana St", "P.O.Box 1234", 1, null);
-    Ebean.save(c);
+    DB.save(c);
     return c;
   }
 
@@ -237,7 +237,7 @@ public class ResetBasicData {
       shippingAddr.setLine1(shippingStreet);
       shippingAddr.setLine2("Sandringham");
       shippingAddr.setCity("Auckland");
-      shippingAddr.setCountry(Ebean.getReference(Country.class, "NZ"));
+      shippingAddr.setCountry(DB.reference(Country.class, "NZ"));
 
       c.setShippingAddress(shippingAddr);
     }
@@ -247,7 +247,7 @@ public class ResetBasicData {
       billingAddr.setLine1(billingStreet);
       billingAddr.setLine2("St Lukes");
       billingAddr.setCity("Auckland");
-      billingAddr.setCountry(Ebean.getReference(Country.class, "NZ"));
+      billingAddr.setCountry(DB.reference(Country.class, "NZ"));
 
       c.setBillingAddress(billingAddr);
     }
@@ -257,9 +257,9 @@ public class ResetBasicData {
 
   private Order createOrder1(Customer customer) {
 
-    Product product1 = Ebean.getReference(Product.class, 1);
-    Product product2 = Ebean.getReference(Product.class, 2);
-    Product product3 = Ebean.getReference(Product.class, 3);
+    Product product1 = DB.reference(Product.class, 1);
+    Product product2 = DB.reference(Product.class, 2);
+    Product product3 = DB.reference(Product.class, 3);
 
 
     Order order = new Order();
@@ -275,13 +275,13 @@ public class ResetBasicData {
 
     order.addShipment(new OrderShipment());
 
-    Ebean.save(order);
+    DB.save(order);
     return order;
   }
 
   private void createOrder2(Customer customer) {
 
-    Product product1 = Ebean.getReference(Product.class, 1);
+    Product product1 = DB.reference(Product.class, 1);
 
     Order order = new Order();
     order.setStatus(Status.SHIPPED);
@@ -294,13 +294,13 @@ public class ResetBasicData {
 
     order.addShipment(new OrderShipment());
 
-    Ebean.save(order);
+    DB.save(order);
   }
 
   private void createOrder3(Customer customer) {
 
-    Product product1 = Ebean.getReference(Product.class, 1);
-    Product product3 = Ebean.getReference(Product.class, 3);
+    Product product1 = DB.reference(Product.class, 1);
+    Product product3 = DB.reference(Product.class, 3);
 
     Order order = new Order();
     order.setStatus(Status.COMPLETE);
@@ -315,7 +315,7 @@ public class ResetBasicData {
 
     order.addShipment(new OrderShipment());
 
-    Ebean.save(order);
+    DB.save(order);
   }
 
   private void createOrder4(Customer customer) {
@@ -326,7 +326,7 @@ public class ResetBasicData {
 
     order.addShipment(new OrderShipment());
 
-    Ebean.save(order);
+    DB.save(order);
   }
 
   private void createOrder5(Customer customer) {
@@ -336,6 +336,6 @@ public class ResetBasicData {
     order.setOrderDate(Date.valueOf("2018-06-28"));
     order.addShipment(new OrderShipment());
 
-    Ebean.save(order);
+    DB.save(order);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Section.java b/ebean-test/src/test/java/org/tests/model/basic/Section.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/basic/Section.java
rename to ebean-test/src/test/java/org/tests/model/basic/Section.java
index 6330543d3..039541188 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Section.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Section.java
@@ -2,11 +2,7 @@ package org.tests.model.basic;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Lob;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/SomeEnum.java b/ebean-test/src/test/java/org/tests/model/basic/SomeEnum.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/SomeEnum.java
rename to ebean-test/src/test/java/org/tests/model/basic/SomeEnum.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/SomeEnumBean.java b/ebean-test/src/test/java/org/tests/model/basic/SomeEnumBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/SomeEnumBean.java
rename to ebean-test/src/test/java/org/tests/model/basic/SomeEnumBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/SomeObject.java b/ebean-test/src/test/java/org/tests/model/basic/SomeObject.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/SomeObject.java
rename to ebean-test/src/test/java/org/tests/model/basic/SomeObject.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/SubSection.java b/ebean-test/src/test/java/org/tests/model/basic/SubSection.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/SubSection.java
rename to ebean-test/src/test/java/org/tests/model/basic/SubSection.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TBytesOnly.java b/ebean-test/src/test/java/org/tests/model/basic/TBytesOnly.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/model/basic/TBytesOnly.java
rename to ebean-test/src/test/java/org/tests/model/basic/TBytesOnly.java
index 22551e37a..80c0f8d36 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/TBytesOnly.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/TBytesOnly.java
@@ -1,10 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.Basic;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.Lob;
+import javax.persistence.*;
 
 @Entity
 public class TBytesOnly {
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TIntChild.java b/ebean-test/src/test/java/org/tests/model/basic/TIntChild.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/TIntChild.java
rename to ebean-test/src/test/java/org/tests/model/basic/TIntChild.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TIntRoot.java b/ebean-test/src/test/java/org/tests/model/basic/TIntRoot.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/model/basic/TIntRoot.java
rename to ebean-test/src/test/java/org/tests/model/basic/TIntRoot.java
index db7d3d89c..e71c03998 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/TIntRoot.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/TIntRoot.java
@@ -1,14 +1,8 @@
 package org.tests.model.basic;
 
+import javax.persistence.*;
 import java.io.Serializable;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-
 @Entity
 @Inheritance
 @DiscriminatorColumn(name = "my_type", length = 3, discriminatorType = DiscriminatorType.INTEGER)
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TJodaEntity.java b/ebean-test/src/test/java/org/tests/model/basic/TJodaEntity.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/TJodaEntity.java
rename to ebean-test/src/test/java/org/tests/model/basic/TJodaEntity.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TMapSuperEntity.java b/ebean-test/src/test/java/org/tests/model/basic/TMapSuperEntity.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/TMapSuperEntity.java
rename to ebean-test/src/test/java/org/tests/model/basic/TMapSuperEntity.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TMappedSuper2.java b/ebean-test/src/test/java/org/tests/model/basic/TMappedSuper2.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/basic/TMappedSuper2.java
rename to ebean-test/src/test/java/org/tests/model/basic/TMappedSuper2.java
index aa3943278..543958ed7 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/TMappedSuper2.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/TMappedSuper2.java
@@ -1,10 +1,9 @@
 package org.tests.model.basic;
 
-import java.io.Serializable;
-
 import javax.persistence.MappedSuperclass;
 import javax.persistence.Transient;
 import javax.persistence.Version;
+import java.io.Serializable;
 
 @MappedSuperclass
 public class TMappedSuper2 implements Serializable {
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TOne.java b/ebean-test/src/test/java/org/tests/model/basic/TOne.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/TOne.java
rename to ebean-test/src/test/java/org/tests/model/basic/TOne.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TSDetail.java b/ebean-test/src/test/java/org/tests/model/basic/TSDetail.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/model/basic/TSDetail.java
rename to ebean-test/src/test/java/org/tests/model/basic/TSDetail.java
index 2898ad07e..50667a784 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/TSDetail.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/TSDetail.java
@@ -3,12 +3,7 @@ package org.tests.model.basic;
 import io.ebean.annotation.Index;
 import io.ebean.annotation.Platform;
 
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
 
 /**
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TSMaster.java b/ebean-test/src/test/java/org/tests/model/basic/TSMaster.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/basic/TSMaster.java
rename to ebean-test/src/test/java/org/tests/model/basic/TSMaster.java
index 7861490ff..6ef9960ba 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/TSMaster.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/TSMaster.java
@@ -1,12 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TUuidEntity.java b/ebean-test/src/test/java/org/tests/model/basic/TUuidEntity.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/TUuidEntity.java
rename to ebean-test/src/test/java/org/tests/model/basic/TUuidEntity.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TWithPreInsert.java b/ebean-test/src/test/java/org/tests/model/basic/TWithPreInsert.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/TWithPreInsert.java
rename to ebean-test/src/test/java/org/tests/model/basic/TWithPreInsert.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Trip.java b/ebean-test/src/test/java/org/tests/model/basic/Trip.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/Trip.java
rename to ebean-test/src/test/java/org/tests/model/basic/Trip.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Truck.java b/ebean-test/src/test/java/org/tests/model/basic/Truck.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/basic/Truck.java
rename to ebean-test/src/test/java/org/tests/model/basic/Truck.java
index 1c7778734..c32d70777 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/Truck.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/Truck.java
@@ -2,11 +2,7 @@ package org.tests.model.basic;
 
 import io.ebean.annotation.DbEnumValue;
 
-import javax.persistence.Column;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.Inheritance;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 
 @Entity
 @Inheritance
diff --git a/ebean-core/src/test/java/org/tests/model/basic/TruckRef.java b/ebean-test/src/test/java/org/tests/model/basic/TruckRef.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/TruckRef.java
rename to ebean-test/src/test/java/org/tests/model/basic/TruckRef.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/UTDetail.java b/ebean-test/src/test/java/org/tests/model/basic/UTDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/UTDetail.java
rename to ebean-test/src/test/java/org/tests/model/basic/UTDetail.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/UTMaster.java b/ebean-test/src/test/java/org/tests/model/basic/UTMaster.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/basic/UTMaster.java
rename to ebean-test/src/test/java/org/tests/model/basic/UTMaster.java
index 7aa42e28a..07c5fec39 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/UTMaster.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/UTMaster.java
@@ -2,12 +2,7 @@ package org.tests.model.basic;
 
 import io.ebean.Model;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.List;
diff --git a/ebean-core/src/test/java/org/tests/model/basic/UUOne.java b/ebean-test/src/test/java/org/tests/model/basic/UUOne.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/basic/UUOne.java
rename to ebean-test/src/test/java/org/tests/model/basic/UUOne.java
index 53c88446a..6a97b4fed 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/UUOne.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/UUOne.java
@@ -2,11 +2,7 @@ package org.tests.model.basic;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 import java.util.UUID;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/UUTwo.java b/ebean-test/src/test/java/org/tests/model/basic/UUTwo.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/basic/UUTwo.java
rename to ebean-test/src/test/java/org/tests/model/basic/UUTwo.java
index f446fe397..1c9116065 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/UUTwo.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/UUTwo.java
@@ -1,10 +1,6 @@
 package org.tests.model.basic;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.UUID;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/ValidationGroupSomething.java b/ebean-test/src/test/java/org/tests/model/basic/ValidationGroupSomething.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/ValidationGroupSomething.java
rename to ebean-test/src/test/java/org/tests/model/basic/ValidationGroupSomething.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/Vehicle.java b/ebean-test/src/test/java/org/tests/model/basic/Vehicle.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/Vehicle.java
rename to ebean-test/src/test/java/org/tests/model/basic/Vehicle.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/VehicleDriver.java b/ebean-test/src/test/java/org/tests/model/basic/VehicleDriver.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/VehicleDriver.java
rename to ebean-test/src/test/java/org/tests/model/basic/VehicleDriver.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/VehicleLease.java b/ebean-test/src/test/java/org/tests/model/basic/VehicleLease.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/VehicleLease.java
rename to ebean-test/src/test/java/org/tests/model/basic/VehicleLease.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/VehicleLeaseLong.java b/ebean-test/src/test/java/org/tests/model/basic/VehicleLeaseLong.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/VehicleLeaseLong.java
rename to ebean-test/src/test/java/org/tests/model/basic/VehicleLeaseLong.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/VehicleLeaseShort.java b/ebean-test/src/test/java/org/tests/model/basic/VehicleLeaseShort.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/VehicleLeaseShort.java
rename to ebean-test/src/test/java/org/tests/model/basic/VehicleLeaseShort.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/VwCustomer.java b/ebean-test/src/test/java/org/tests/model/basic/VwCustomer.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/basic/VwCustomer.java
rename to ebean-test/src/test/java/org/tests/model/basic/VwCustomer.java
index ba5130156..72fbc08cf 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/VwCustomer.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/VwCustomer.java
@@ -1,24 +1,9 @@
 package org.tests.model.basic;
 
-import io.ebean.annotation.Cache;
-import io.ebean.annotation.ChangeLog;
-import io.ebean.annotation.ChangeLogInsertMode;
-import io.ebean.annotation.DbComment;
-import io.ebean.annotation.DbEnumValue;
-import io.ebean.annotation.DocEmbedded;
-import io.ebean.annotation.DocStore;
-import io.ebean.annotation.JsonIgnore;
-import io.ebean.annotation.View;
-import io.ebean.annotation.Where;
+import io.ebean.annotation.*;
 import org.tests.model.basic.finder.CustomerFinder;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.ManyToOne;
-import javax.persistence.NamedQueries;
-import javax.persistence.NamedQuery;
-import javax.persistence.OneToMany;
-import javax.persistence.Transient;
+import javax.persistence.*;
 import javax.validation.constraints.NotNull;
 import javax.validation.constraints.Size;
 import java.sql.Date;
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/CInhOne.java b/ebean-test/src/test/java/org/tests/model/basic/cache/CInhOne.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/CInhOne.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/CInhOne.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/CInhRef.java b/ebean-test/src/test/java/org/tests/model/basic/cache/CInhRef.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/CInhRef.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/CInhRef.java
index 63e918724..fcfb8479f 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/cache/CInhRef.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/cache/CInhRef.java
@@ -1,8 +1,7 @@
 package org.tests.model.basic.cache;
 
-import org.tests.model.basic.BasicDomain;
-
 import io.ebean.annotation.Cache;
+import org.tests.model.basic.BasicDomain;
 
 import javax.persistence.Entity;
 import javax.persistence.ManyToOne;
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/CInhRoot.java b/ebean-test/src/test/java/org/tests/model/basic/cache/CInhRoot.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/CInhRoot.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/CInhRoot.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/CInhTwo.java b/ebean-test/src/test/java/org/tests/model/basic/cache/CInhTwo.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/CInhTwo.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/CInhTwo.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/ECacheChild.java b/ebean-test/src/test/java/org/tests/model/basic/cache/ECacheChild.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/ECacheChild.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/ECacheChild.java
index fb96be1d3..bed1d44ab 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/cache/ECacheChild.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/cache/ECacheChild.java
@@ -1,6 +1,6 @@
 package org.tests.model.basic.cache;
 
-import java.util.UUID;
+import io.ebean.annotation.Cache;
 
 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
@@ -8,8 +8,7 @@ import javax.persistence.Id;
 import javax.persistence.ManyToOne;
 import javax.validation.constraints.NotNull;
 import javax.validation.constraints.Size;
-
-import io.ebean.annotation.Cache;
+import java.util.UUID;
 
 @Entity
 @Cache(enableQueryCache = true, enableBeanCache = false)
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/ECacheRoot.java b/ebean-test/src/test/java/org/tests/model/basic/cache/ECacheRoot.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/ECacheRoot.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/ECacheRoot.java
index 5c9925c35..7c458bd12 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/cache/ECacheRoot.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/cache/ECacheRoot.java
@@ -1,13 +1,12 @@
 package org.tests.model.basic.cache;
 
-import java.util.UUID;
+import io.ebean.annotation.Cache;
 
 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.Id;
 import javax.validation.constraints.Size;
-
-import io.ebean.annotation.Cache;
+import java.util.UUID;
 
 @Entity
 @Cache(enableQueryCache = true, enableBeanCache = false)
diff --git a/ebean-test/src/test/java/org/tests/model/basic/cache/ESoftWithCache.java b/ebean-test/src/test/java/org/tests/model/basic/cache/ESoftWithCache.java
new file mode 100644
index 000000000..d570e1e4a
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/model/basic/cache/ESoftWithCache.java
@@ -0,0 +1,69 @@
+package org.tests.model.basic.cache;
+
+import io.ebean.Model;
+import io.ebean.annotation.Cache;
+import io.ebean.annotation.SoftDelete;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Version;
+
+@Cache
+@Entity
+@Table(name = "e_softwithcache")
+public class ESoftWithCache extends Model {
+
+  @Id
+  long id;
+
+  String name;
+
+  String description;
+
+  @SoftDelete
+  boolean deleted;
+
+  @Version
+  long version;
+
+  public ESoftWithCache(String name) {
+    this.name = name;
+  }
+
+  public long id() {
+    return id;
+  }
+
+  public ESoftWithCache id(long id) {
+    this.id = id;
+    return this;
+  }
+
+  public String name() {
+    return name;
+  }
+
+  public ESoftWithCache name(String name) {
+    this.name = name;
+    return this;
+  }
+
+  public String description() {
+    return description;
+  }
+
+  public ESoftWithCache description(String description) {
+    this.description = description;
+    return this;
+  }
+
+  public long version() {
+    return version;
+  }
+
+  public ESoftWithCache version(long version) {
+    this.version = version;
+    return this;
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/OCacheBase.java b/ebean-test/src/test/java/org/tests/model/basic/cache/OCacheBase.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/OCacheBase.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/OCacheBase.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/OCachedApp.java b/ebean-test/src/test/java/org/tests/model/basic/cache/OCachedApp.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/OCachedApp.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/OCachedApp.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/OCachedAppDetail.java b/ebean-test/src/test/java/org/tests/model/basic/cache/OCachedAppDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/OCachedAppDetail.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/OCachedAppDetail.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/OCachedNatKeyBean.java b/ebean-test/src/test/java/org/tests/model/basic/cache/OCachedNatKeyBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/OCachedNatKeyBean.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/OCachedNatKeyBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/OCachedNatKeyBean3.java b/ebean-test/src/test/java/org/tests/model/basic/cache/OCachedNatKeyBean3.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/OCachedNatKeyBean3.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/OCachedNatKeyBean3.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/OCachedNkeyUid.java b/ebean-test/src/test/java/org/tests/model/basic/cache/OCachedNkeyUid.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/OCachedNkeyUid.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/OCachedNkeyUid.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey.java b/ebean-test/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey.java
index 3b2cfc5f5..5bfaa970d 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey.java
@@ -2,12 +2,12 @@ package org.tests.model.basic.cache;
 
 import io.ebean.BaseTestCase;
 import io.ebean.CacheMode;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheManager;
 import io.ebean.cache.ServerCacheStatistics;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -21,18 +21,18 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
 
   private static final Logger log = LoggerFactory.getLogger(TestCacheViaComplexNaturalKey.class);
 
-  private ServerCache beanCache = cacheManager().getBeanCache(OCachedNatKeyBean.class);
-  private ServerCache natKeyCache = cacheManager().getNaturalKeyCache(OCachedNatKeyBean.class);
+  private ServerCache beanCache = cacheManager().beanCache(OCachedNatKeyBean.class);
+  private ServerCache natKeyCache = cacheManager().naturalKeyCache(OCachedNatKeyBean.class);
 
   private static boolean loadOnce;
 
   private ServerCacheManager cacheManager() {
-    return server().getServerCacheManager();
+    return server().cacheManager();
   }
 
   private static void insertSome() {
     if (!loadOnce) {
-      Ebean.find(OCachedNatKeyBean.class).delete();
+      DB.find(OCachedNatKeyBean.class).delete();
       for (String store : Arrays.asList("abc", "def")) {
         for (String sku : Arrays.asList("1", "2", "3", "4")) {
           saveBean(store, sku);
@@ -43,26 +43,26 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
   }
 
   private static void saveBean(String abc, String sku) {
-    Ebean.save(new OCachedNatKeyBean(abc, sku));
+    DB.save(new OCachedNatKeyBean(abc, sku));
   }
 
   private void clearCacheAndStatistics() {
-    Ebean.getServerCacheManager().clearAll();
+    DB.cacheManager().clearAll();
     clearStatistics();
   }
 
   private void clearStatistics() {
-    beanCache.getStatistics(true);
-    natKeyCache.getStatistics(true);
+    beanCache.statistics(true);
+    natKeyCache.statistics(true);
   }
 
   private void assertNaturalKeyHitMiss(int expectedHit, int expectedMiss) {
-    ServerCacheStatistics stats = natKeyCache.getStatistics(true);
+    ServerCacheStatistics stats = natKeyCache.statistics(true);
     assertHitMiss(expectedHit, expectedMiss, stats);
   }
 
   private void assertBeanCacheHitMiss(int expectedHit, int expectedMiss) {
-    ServerCacheStatistics stats = beanCache.getStatistics(true);
+    ServerCacheStatistics stats = beanCache.statistics(true);
     assertHitMiss(expectedHit, expectedMiss, stats);
   }
 
@@ -78,7 +78,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
 
   private void loadSomeIntoCache() {
 
-    Ebean.find(OCachedNatKeyBean.class)
+    DB.find(OCachedNatKeyBean.class)
       .setBeanCacheMode(CacheMode.PUT)
       .where().le("sku", "2")
       .findList();
@@ -95,10 +95,10 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
     String storeId = "abc";
     List<String> skus = Arrays.asList("1", "2", "3");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     log.info("Partial (2 of 3) ...");
-    List<OCachedNatKeyBean> list = Ebean.find(OCachedNatKeyBean.class)
+    List<OCachedNatKeyBean> list = DB.find(OCachedNatKeyBean.class)
       .where()
       .eq("store", storeId)
       .in("sku", skus)
@@ -106,7 +106,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
       .order("sku desc")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     if (isH2()) {
       // in clause with only 1 bind param - (sku=3 ... we got hits on sku 1 and 2)
@@ -117,7 +117,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
     assertNaturalKeyHitMiss(2, 1);
     assertBeanCacheHitMiss(2, 0);
 
-    list = Ebean.find(OCachedNatKeyBean.class)
+    list = DB.find(OCachedNatKeyBean.class)
       .where()
       .eq("store", storeId)
       .in("sku", skus)
@@ -125,7 +125,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
       .order("sku desc")
       .findList();
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
 
     assertThat(list).hasSize(3);
     assertThat(sql).hasSize(0);
@@ -136,7 +136,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
     natKeyCache.remove("abc;3;");
 
     log.info("Partial (1 of 3) ...");
-    list = Ebean.find(OCachedNatKeyBean.class)
+    list = DB.find(OCachedNatKeyBean.class)
       .where()
       .eq("store", storeId)
       .in("sku", skus)
@@ -144,7 +144,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
       .order("sku desc")
       .findList();
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
 
     assertThat(list).hasSize(3);
     assertThat(sql).hasSize(1);
@@ -164,9 +164,9 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
     String storeId = "abc";
     List<String> skus = new ArrayList<>(Arrays.asList("1", "2"));
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<OCachedNatKeyBean> list = Ebean.find(OCachedNatKeyBean.class)
+    List<OCachedNatKeyBean> list = DB.find(OCachedNatKeyBean.class)
       .where()
       .eq("store", storeId)
       .in("sku", skus)
@@ -174,7 +174,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
       .order("sku desc")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     // no SQL - all beans from cache
     assertThat(sql).isEmpty();
@@ -193,9 +193,9 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
     String storeId = "abc";
     List<String> skus = new ArrayList<>(Arrays.asList("3", "4"));
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<OCachedNatKeyBean> list = Ebean.find(OCachedNatKeyBean.class)
+    List<OCachedNatKeyBean> list = DB.find(OCachedNatKeyBean.class)
       .where()
       .eq("store", storeId)
       .in("sku", skus)
@@ -203,7 +203,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
       .order("sku desc")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isH2()) {
       // in clause with 2 bind params as we got not hits on the cache
@@ -222,7 +222,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
     loadSomeIntoCache();
 
     // simple case - no IN clause
-    OCachedNatKeyBean hit = Ebean.find(OCachedNatKeyBean.class)
+    OCachedNatKeyBean hit = DB.find(OCachedNatKeyBean.class)
       .where()
       .eq("store", "abc")
       .eq("sku", "2")
@@ -239,7 +239,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
 
     setup();
 
-    OCachedNatKeyBean miss = Ebean.find(OCachedNatKeyBean.class)
+    OCachedNatKeyBean miss = DB.find(OCachedNatKeyBean.class)
       .where()
       .eq("store", "def")
       .eq("sku", "4")
@@ -260,7 +260,7 @@ public class TestCacheViaComplexNaturalKey extends BaseTestCase {
 
     setup();
 
-    OCachedNatKeyBean miss = Ebean.find(OCachedNatKeyBean.class)
+    OCachedNatKeyBean miss = DB.find(OCachedNatKeyBean.class)
       .where()
       .eq("store", "def")
       .eq("sku", "4")
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey3.java b/ebean-test/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey3.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey3.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey3.java
index 236b2545e..3e058676b 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey3.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/cache/TestCacheViaComplexNaturalKey3.java
@@ -2,15 +2,14 @@ package org.tests.model.basic.cache;
 
 import io.ebean.BaseTestCase;
 import io.ebean.CacheMode;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Pairs;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheManager;
 import io.ebean.cache.ServerCacheStatistics;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
@@ -19,18 +18,18 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
 
-  private ServerCache beanCache = cacheManager().getBeanCache(OCachedNatKeyBean3.class);
-  private ServerCache natKeyCache = cacheManager().getNaturalKeyCache(OCachedNatKeyBean3.class);
+  private ServerCache beanCache = cacheManager().beanCache(OCachedNatKeyBean3.class);
+  private ServerCache natKeyCache = cacheManager().naturalKeyCache(OCachedNatKeyBean3.class);
 
   private static boolean loadOnce;
 
   private ServerCacheManager cacheManager() {
-    return server().getServerCacheManager();
+    return server().cacheManager();
   }
 
   private static void insertSome() {
     if (!loadOnce) {
-      Ebean.find(OCachedNatKeyBean3.class).delete();
+      DB.find(OCachedNatKeyBean3.class).delete();
 
       List<String> stores = asList("abc", "def");
       for (String store : stores) {
@@ -47,26 +46,26 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
   }
 
   private static void saveBean(String store, int code, String sku) {
-    Ebean.save(new OCachedNatKeyBean3(store, code, sku));
+    DB.save(new OCachedNatKeyBean3(store, code, sku));
   }
 
   private void clearCacheAndStatistics() {
-    Ebean.getServerCacheManager().clearAll();
+    DB.cacheManager().clearAll();
     clearStatistics();
   }
 
   private void clearStatistics() {
-    beanCache.getStatistics(true);
-    natKeyCache.getStatistics(true);
+    beanCache.statistics(true);
+    natKeyCache.statistics(true);
   }
 
   private void assertNaturalKeyHitMiss(int expectedHit, int expectedMiss) {
-    ServerCacheStatistics stats = natKeyCache.getStatistics(true);
+    ServerCacheStatistics stats = natKeyCache.statistics(true);
     assertHitMiss(expectedHit, expectedMiss, stats);
   }
 
   private void assertBeanCacheHitMiss(int expectedHit, int expectedMiss) {
-    ServerCacheStatistics stats = beanCache.getStatistics(true);
+    ServerCacheStatistics stats = beanCache.statistics(true);
     assertHitMiss(expectedHit, expectedMiss, stats);
   }
 
@@ -82,7 +81,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
 
   private void loadSomeIntoCache() {
 
-    Ebean.find(OCachedNatKeyBean3.class)
+    DB.find(OCachedNatKeyBean3.class)
       .setBeanCacheMode(CacheMode.PUT)
       .where()
       .ge("sku", "2")
@@ -101,9 +100,9 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
 
     List<Integer> codes = asList(1001);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Map<String,OCachedNatKeyBean3> list = Ebean.find(OCachedNatKeyBean3.class)
+    Map<String,OCachedNatKeyBean3> list = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", "def")
       .eq("sku", "2")
@@ -113,7 +112,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
       .setMapKey("sku")
       .findMap();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).isEmpty();
 
     assertThat(list).hasSize(1);
@@ -130,9 +129,9 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
 
     List<Integer> codes = asList(1001, 1000);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Map<String,OCachedNatKeyBean3> list = Ebean.find(OCachedNatKeyBean3.class)
+    Map<String,OCachedNatKeyBean3> list = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", "def")
       .eq("sku", "2")
@@ -142,7 +141,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
       .setMapKey("sku")
       .findMap();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isH2()) {
       // in clause with only 1 bind param - miss on 1000
@@ -159,9 +158,9 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
 
     setup();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Map<String,OCachedNatKeyBean3> map = Ebean.find(OCachedNatKeyBean3.class)
+    Map<String,OCachedNatKeyBean3> map = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", "def")
       .eq("sku", "2")
@@ -170,7 +169,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
       .setMapKey("code")
       .findMap();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isH2()) {
       // in clause with only 1 bind param - miss on 1000, 1002
@@ -191,9 +190,9 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
 
     List<Integer> codes = asList(1001, 1000, 1002, 1003);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<OCachedNatKeyBean3> list = Ebean.find(OCachedNatKeyBean3.class)
+    List<OCachedNatKeyBean3> list = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", "def")
       .in("code", codes)
@@ -203,7 +202,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
       .order().asc("code")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isH2()) {
       // in clause with only 1 bind param - (sku=3 ... we got hits on sku 1 and 2)
@@ -224,9 +223,9 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
 
     List<String> skus = asList("2", "3");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<OCachedNatKeyBean3> list = Ebean.find(OCachedNatKeyBean3.class)
+    List<OCachedNatKeyBean3> list = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", "def")
       .in("sku", skus)
@@ -235,7 +234,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
       .order("sku desc")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     // no SQL - all beans from cache
     assertThat(sql).isEmpty();
@@ -254,9 +253,9 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
     String storeId = "abc";
     List<String> skus = asList("3", "2", "4");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<OCachedNatKeyBean3> list = Ebean.find(OCachedNatKeyBean3.class)
+    List<OCachedNatKeyBean3> list = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", storeId)
       .in("sku", skus)
@@ -265,7 +264,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
       .order("sku desc")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isH2()) {
       // in clause with 2 bind params as we got not hits on the cache
@@ -285,7 +284,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
     loadSomeIntoCache();
 
     // simple case - no IN clause
-    OCachedNatKeyBean3 hit = Ebean.find(OCachedNatKeyBean3.class)
+    OCachedNatKeyBean3 hit = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", "def")
       .eq("sku", "2")
@@ -303,7 +302,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
 
     setup();
 
-    OCachedNatKeyBean3 miss = Ebean.find(OCachedNatKeyBean3.class)
+    OCachedNatKeyBean3 miss = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", "abc")
       .eq("sku", "2")
@@ -324,7 +323,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
 
     setup();
 
-    OCachedNatKeyBean3 miss = Ebean.find(OCachedNatKeyBean3.class)
+    OCachedNatKeyBean3 miss = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", "abc")
       .eq("sku", "2")
@@ -350,9 +349,9 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
       .add("2", 1001)
       .add("3", 1000);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<OCachedNatKeyBean3> list = Ebean.find(OCachedNatKeyBean3.class)
+    List<OCachedNatKeyBean3> list = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", "def")
       .inPairs(pairs)
@@ -360,7 +359,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
       .order("sku desc")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(pairs.getEntries()).hasSize(3);
 
@@ -393,9 +392,9 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
       .add("2", 1001)
       .add("3", 1000);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<OCachedNatKeyBean3> list = Ebean.find(OCachedNatKeyBean3.class)
+    List<OCachedNatKeyBean3> list = DB.find(OCachedNatKeyBean3.class)
       .where()
       .eq("store", "def")
       .inPairs(pairs)
@@ -403,7 +402,7 @@ public class TestCacheViaComplexNaturalKey3 extends BaseTestCase {
       .order("sku desc")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(pairs.getEntries()).hasSize(3);
 
diff --git a/ebean-test/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java b/ebean-test/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java
new file mode 100644
index 000000000..0f4a902c3
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java
@@ -0,0 +1,46 @@
+package org.tests.model.basic.cache;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.cache.ServerCache;
+import io.ebean.cache.ServerCacheStatistics;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestCacheWithSoftDelete extends BaseTestCase {
+
+  private final ServerCache beanCache = DB.cacheManager().beanCache(ESoftWithCache.class);
+
+  @Test
+  public void idIn_expect_hitCache() {
+    ESoftWithCache bean = new ESoftWithCache("hello");
+    DB.save(bean);
+
+    final List<ESoftWithCache> found = DB.find(ESoftWithCache.class)
+      .where().idIn(bean.id())
+      .findList();
+    assertThat(found).hasSize(1);
+
+    // try to hit the cache
+    assertThat(stats().getPutCount()).isEqualTo(1);
+
+    LoggedSql.start();
+    // cache hit success this time
+    final List<ESoftWithCache> foundAgain = DB.find(ESoftWithCache.class)
+      .where().idIn(bean.id())
+      .findList();
+
+    final List<String> sql = LoggedSql.stop();
+    assertThat(sql).isEmpty();
+    assertThat(foundAgain).hasSize(1);
+    assertThat(stats().getHitCount()).isEqualTo(1);
+  }
+
+  private ServerCacheStatistics stats() {
+    return beanCache.statistics(true);
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWhenNull.java b/ebean-test/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWhenNull.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWhenNull.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWhenNull.java
index 13c8a299c..ac34b2fce 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWhenNull.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWhenNull.java
@@ -2,7 +2,7 @@ package org.tests.model.basic.cache;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWithForeignKey.java b/ebean-test/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWithForeignKey.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWithForeignKey.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWithForeignKey.java
index d40c14ac5..674b060c4 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWithForeignKey.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/cache/TestNatKeyCacheWithForeignKey.java
@@ -3,8 +3,8 @@ package org.tests.model.basic.cache;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.cache.ServerCacheStatistics;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -37,12 +37,12 @@ public class TestNatKeyCacheWithForeignKey extends BaseTestCase {
 
     resetAllMetrics();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     final OCachedAppDetail found1 = findDetail(app0, "detail0");
     assertThat(found1).isNotNull();
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).as("Expected cache hit, no SQL query expected").isEmpty();
     assertThat(getStats().getHitCount()).isEqualTo(1);
   }
@@ -67,11 +67,11 @@ public class TestNatKeyCacheWithForeignKey extends BaseTestCase {
     assertThat(result0).hasSize(2);
     assertThat(getStats().getHitCount()).isEqualTo(0);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     final List<OCachedAppDetail> result1 = findListDetails(app0, "detail0", "detail1");
     assertThat(result1).hasSize(2);
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).as("Expected cache hit, no SQL query expected").isEmpty();
     assertThat(getStats().getHitCount()).isEqualTo(2);
   }
@@ -96,11 +96,11 @@ public class TestNatKeyCacheWithForeignKey extends BaseTestCase {
     assertThat(result0).hasSize(2);
     assertThat(getStats().getHitCount()).isEqualTo(0);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     final List<OCachedAppDetail> result1 = findListApps("detail0", app0, app1);
     assertThat(result1).hasSize(2);
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).as("Expected cache hit, no SQL query expected").isEmpty();
     assertThat(getStats().getHitCount()).isEqualTo(2);
   }
diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/TestNatKeyUid.java b/ebean-test/src/test/java/org/tests/model/basic/cache/TestNatKeyUid.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/basic/cache/TestNatKeyUid.java
rename to ebean-test/src/test/java/org/tests/model/basic/cache/TestNatKeyUid.java
index 74ecd0f08..ba6a16ac2 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/cache/TestNatKeyUid.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/cache/TestNatKeyUid.java
@@ -3,14 +3,14 @@ package org.tests.model.basic.cache;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.cache.ServerCacheStatistics;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestNatKeyUid extends BaseTestCase {
 
@@ -55,12 +55,12 @@ public class TestNatKeyUid extends BaseTestCase {
     assertThat(result).hasSize(2);
     assertThat(appStats().getHitCount()).isEqualTo(0);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     result = findMany();
     assertThat(result).hasSize(2);
     assertThat(appStats().getHitCount()).isEqualTo(2);
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).as("Expected hit cache, no sql").isEmpty();
   }
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/event/CustomerPersistAdapter.java b/ebean-test/src/test/java/org/tests/model/basic/event/CustomerPersistAdapter.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/event/CustomerPersistAdapter.java
rename to ebean-test/src/test/java/org/tests/model/basic/event/CustomerPersistAdapter.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/event/SimpleTOneQueryAdapter.java b/ebean-test/src/test/java/org/tests/model/basic/event/SimpleTOneQueryAdapter.java
similarity index 95%
rename from ebean-core/src/test/java/org/tests/model/basic/event/SimpleTOneQueryAdapter.java
rename to ebean-test/src/test/java/org/tests/model/basic/event/SimpleTOneQueryAdapter.java
index 6a4ccd346..d32597d9f 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/event/SimpleTOneQueryAdapter.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/event/SimpleTOneQueryAdapter.java
@@ -21,7 +21,7 @@ public class SimpleTOneQueryAdapter implements BeanQueryAdapter {
   @Override
   public void preQuery(BeanQueryRequest<?> request) {
 
-    Query<?> query = request.getQuery();
+    Query<?> query = request.query();
 
     switch (query.getQueryType()) {
       case DELETE: {
diff --git a/ebean-core/src/test/java/org/tests/model/basic/event/TWithPreInsertPersistAdapter.java b/ebean-test/src/test/java/org/tests/model/basic/event/TWithPreInsertPersistAdapter.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/basic/event/TWithPreInsertPersistAdapter.java
rename to ebean-test/src/test/java/org/tests/model/basic/event/TWithPreInsertPersistAdapter.java
index 06018dcec..41b6fe141 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/event/TWithPreInsertPersistAdapter.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/event/TWithPreInsertPersistAdapter.java
@@ -14,7 +14,7 @@ public class TWithPreInsertPersistAdapter extends BeanPersistAdapter {
   @Override
   public boolean preInsert(BeanPersistRequest<?> request) {
 
-    TWithPreInsert e = (TWithPreInsert) request.getBean();
+    TWithPreInsert e = (TWithPreInsert) request.bean();
     if (e.getName() == null) {
       e.setName("set on preInsert");
     }
@@ -24,7 +24,7 @@ public class TWithPreInsertPersistAdapter extends BeanPersistAdapter {
   @Override
   public boolean preUpdate(BeanPersistRequest<?> request) {
 
-    TWithPreInsert b = (TWithPreInsert) request.getBean();
+    TWithPreInsert b = (TWithPreInsert) request.bean();
     System.out.println("preUpdate - title is: " + b.getTitle());
     if (b.getTitle() == null) {
       b.setTitle("set on preUpdate");
diff --git a/ebean-core/src/test/java/org/tests/model/basic/finder/CustomerFinder.java b/ebean-test/src/test/java/org/tests/model/basic/finder/CustomerFinder.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/finder/CustomerFinder.java
rename to ebean-test/src/test/java/org/tests/model/basic/finder/CustomerFinder.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/first/First.java b/ebean-test/src/test/java/org/tests/model/basic/first/First.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/model/basic/first/First.java
rename to ebean-test/src/test/java/org/tests/model/basic/first/First.java
index 8c848ed10..d6c96c825 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/first/First.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/first/First.java
@@ -1,10 +1,6 @@
 package org.tests.model.basic.first;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "f_first")
diff --git a/ebean-core/src/test/java/org/tests/model/basic/first/Second.java b/ebean-test/src/test/java/org/tests/model/basic/first/Second.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/model/basic/first/Second.java
rename to ebean-test/src/test/java/org/tests/model/basic/first/Second.java
index ca015b149..dd3ffd624 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/first/Second.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/first/Second.java
@@ -1,10 +1,6 @@
 package org.tests.model.basic.first;
 
-import javax.persistence.AttributeOverride;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @AttributeOverride(name = "name", column = @Column(name = "mod_name"))
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/first/SuperSecond.java b/ebean-test/src/test/java/org/tests/model/basic/first/SuperSecond.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/first/SuperSecond.java
rename to ebean-test/src/test/java/org/tests/model/basic/first/SuperSecond.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/first/TestFirstSecond.java b/ebean-test/src/test/java/org/tests/model/basic/first/TestFirstSecond.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/model/basic/first/TestFirstSecond.java
rename to ebean-test/src/test/java/org/tests/model/basic/first/TestFirstSecond.java
index 9907fa04e..8a4b17d12 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/first/TestFirstSecond.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/first/TestFirstSecond.java
@@ -1,8 +1,8 @@
 package org.tests.model.basic.first;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 public class TestFirstSecond extends BaseTestCase {
 
@@ -11,17 +11,17 @@ public class TestFirstSecond extends BaseTestCase {
 
     First first = new First();
     first.setName("first");
-    Ebean.save(first);
+    DB.save(first);
 
     Second second = new Second();
     second.setName("Jim");
     second.setTitle("Sir");
     second.setFirst(first);
-    Ebean.save(second);
+    DB.save(second);
 
 
     second.getFirst().setName("changed");
-    Ebean.save(second);
-    Ebean.save(first);
+    DB.save(second);
+    DB.save(first);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/basic/mapsuper/MapSuperActual.java b/ebean-test/src/test/java/org/tests/model/basic/mapsuper/MapSuperActual.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/mapsuper/MapSuperActual.java
rename to ebean-test/src/test/java/org/tests/model/basic/mapsuper/MapSuperActual.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/mapsuper/MapSuperNoId.java b/ebean-test/src/test/java/org/tests/model/basic/mapsuper/MapSuperNoId.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/basic/mapsuper/MapSuperNoId.java
rename to ebean-test/src/test/java/org/tests/model/basic/mapsuper/MapSuperNoId.java
index 22b535c86..d9781a5cb 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/mapsuper/MapSuperNoId.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/mapsuper/MapSuperNoId.java
@@ -1,6 +1,6 @@
 package org.tests.model.basic.mapsuper;
 
-import io.ebean.annotation.CreatedTimestamp;
+import io.ebean.annotation.WhenCreated;
 
 import javax.persistence.MappedSuperclass;
 import javax.persistence.Version;
@@ -9,7 +9,7 @@ import java.sql.Timestamp;
 @MappedSuperclass
 public class MapSuperNoId {
 
-  @CreatedTimestamp
+  @WhenCreated
   Timestamp whenCreated;
 
   @Version
diff --git a/ebean-core/src/test/java/org/tests/model/basic/mapsuper/TestMapSuperEquals.java b/ebean-test/src/test/java/org/tests/model/basic/mapsuper/TestMapSuperEquals.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/model/basic/mapsuper/TestMapSuperEquals.java
rename to ebean-test/src/test/java/org/tests/model/basic/mapsuper/TestMapSuperEquals.java
index 85f7c06c0..7dff5caf5 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/mapsuper/TestMapSuperEquals.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/mapsuper/TestMapSuperEquals.java
@@ -2,8 +2,10 @@ package org.tests.model.basic.mapsuper;
 
 import io.ebean.BaseTestCase;
 import io.ebean.bean.EntityBean;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 
 public class TestMapSuperEquals extends BaseTestCase {
 
@@ -23,10 +25,10 @@ public class TestMapSuperEquals extends BaseTestCase {
 
       a.setId(456l);
 
-      Assert.assertTrue("equals By Id value on enhanced mapped super", a.equals(b));
-      Assert.assertTrue(b.equals(a));
-      Assert.assertTrue(!a.equals(c));
-      Assert.assertTrue(!b.equals(c));
+      assertEquals(a, b);
+      assertEquals(b, a);
+      assertNotEquals(a, c);
+      assertNotEquals(b, c);
 
     } else {
       System.out.println("--- ok, not running TestMapSuperEquals test");
diff --git a/ebean-core/src/test/java/org/tests/model/basic/metaannotation/SizeMedium.java b/ebean-test/src/test/java/org/tests/model/basic/metaannotation/SizeMedium.java
similarity index 60%
rename from ebean-core/src/test/java/org/tests/model/basic/metaannotation/SizeMedium.java
rename to ebean-test/src/test/java/org/tests/model/basic/metaannotation/SizeMedium.java
index ce1d7a68d..5f73cc56c 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/metaannotation/SizeMedium.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/metaannotation/SizeMedium.java
@@ -1,11 +1,7 @@
 package org.tests.model.basic.metaannotation;
 
 import javax.validation.constraints.Size;
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.lang.annotation.*;
 
 /**
  * Meta-Annotation that defines &#64;Size(max=100)
diff --git a/ebean-core/src/test/java/org/tests/model/basic/xtra/DummyDao.java b/ebean-test/src/test/java/org/tests/model/basic/xtra/DummyDao.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/basic/xtra/DummyDao.java
rename to ebean-test/src/test/java/org/tests/model/basic/xtra/DummyDao.java
index 29caa03a4..3f38c166e 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/xtra/DummyDao.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/xtra/DummyDao.java
@@ -1,6 +1,6 @@
 package org.tests.model.basic.xtra;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.annotation.Transactional;
@@ -8,9 +8,7 @@ import io.ebean.annotation.TxType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class DummyDao {
 
@@ -20,7 +18,7 @@ public class DummyDao {
   public void doSomething() {
 
     logger.info("  --- in DummyDao.doSomething() with TxType.REQUIRES_NEW");
-    Transaction txn = Ebean.currentTransaction();
+    Transaction txn = DB.currentTransaction();
     if (txn == null) {
       logger.error("  NO TRANSACTION ??");
     } else {
@@ -32,7 +30,7 @@ public class DummyDao {
   @Transactional(batch = PersistBatch.ALL, batchOnCascade = PersistBatch.ALL, batchSize = 99)
   private void doWithBatchOptionsSet() {
 
-    Transaction txn = Ebean.currentTransaction();
+    Transaction txn = DB.currentTransaction();
     assertTrue(txn.isBatchMode());
     assertTrue(txn.isBatchOnCascade());
     assertEquals(99, txn.getBatchSize());
@@ -42,7 +40,7 @@ public class DummyDao {
   @Transactional(batch = PersistBatch.ALL, batchOnCascade = PersistBatch.NONE, batchSize = 77)
   public void doOuterWithBatchOptionsSet() {
 
-    Transaction txn = Ebean.currentTransaction();
+    Transaction txn = DB.currentTransaction();
 
     assertTrue(txn.isBatchMode());
     assertFalse(txn.isBatchOnCascade());
diff --git a/ebean-core/src/test/java/org/tests/model/basic/xtra/EdChild.java b/ebean-test/src/test/java/org/tests/model/basic/xtra/EdChild.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/model/basic/xtra/EdChild.java
rename to ebean-test/src/test/java/org/tests/model/basic/xtra/EdChild.java
index ccbb77d38..c405b9ed7 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/xtra/EdChild.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/xtra/EdChild.java
@@ -1,11 +1,6 @@
 package org.tests.model.basic.xtra;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "td_child")
diff --git a/ebean-core/src/test/java/org/tests/model/basic/xtra/EdExtendedParent.java b/ebean-test/src/test/java/org/tests/model/basic/xtra/EdExtendedParent.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/basic/xtra/EdExtendedParent.java
rename to ebean-test/src/test/java/org/tests/model/basic/xtra/EdExtendedParent.java
diff --git a/ebean-core/src/test/java/org/tests/model/basic/xtra/EdParent.java b/ebean-test/src/test/java/org/tests/model/basic/xtra/EdParent.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/model/basic/xtra/EdParent.java
rename to ebean-test/src/test/java/org/tests/model/basic/xtra/EdParent.java
index 5347430fc..1f401072c 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/xtra/EdParent.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/xtra/EdParent.java
@@ -1,18 +1,7 @@
 package org.tests.model.basic.xtra;
 
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/basic/xtra/OptimisticLockExceptionThrowingDao.java b/ebean-test/src/test/java/org/tests/model/basic/xtra/OptimisticLockExceptionThrowingDao.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/model/basic/xtra/OptimisticLockExceptionThrowingDao.java
rename to ebean-test/src/test/java/org/tests/model/basic/xtra/OptimisticLockExceptionThrowingDao.java
index fbaeac4d2..0412c5d75 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/xtra/OptimisticLockExceptionThrowingDao.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/xtra/OptimisticLockExceptionThrowingDao.java
@@ -1,23 +1,24 @@
 package org.tests.model.basic.xtra;
 
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.SqlUpdate;
 import io.ebean.Transaction;
 import io.ebean.annotation.Transactional;
 import org.tests.model.basic.EBasicVer;
-import org.junit.Assert;
 
 import javax.persistence.PersistenceException;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+
 public class OptimisticLockExceptionThrowingDao {
 
   Transaction inMethodTransaction;
 
   @Transactional
   public void doSomething(EBasicVer v) {
-
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     inMethodTransaction = server.currentTransaction();
 
@@ -25,15 +26,15 @@ public class OptimisticLockExceptionThrowingDao {
     SqlUpdate u = server.sqlUpdate("update e_basicver set last_update = last_update+1 where id = ?");
     u.setParameter(1, v.getId());
     int count = server.execute(u, t);
-    Assert.assertEquals(1, count);
+    assertEquals(1, count);
 
     t.commit();
 
     v.setName("some change");
     try {
-      Ebean.save(v);
+      DB.save(v);
       // never get here
-      Assert.assertTrue(false);
+      fail();
     } catch (PersistenceException e) {
       throw e;
     }
diff --git a/ebean-core/src/test/java/org/tests/model/basic/xtra/TestDeleteUnloadedChildren.java b/ebean-test/src/test/java/org/tests/model/basic/xtra/TestDeleteUnloadedChildren.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/model/basic/xtra/TestDeleteUnloadedChildren.java
rename to ebean-test/src/test/java/org/tests/model/basic/xtra/TestDeleteUnloadedChildren.java
index 2291bd0b7..6b553e01a 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/xtra/TestDeleteUnloadedChildren.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/xtra/TestDeleteUnloadedChildren.java
@@ -1,10 +1,10 @@
 package org.tests.model.basic.xtra;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.SqlUpdate;
 import io.ebean.Transaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 
@@ -12,16 +12,16 @@ public class TestDeleteUnloadedChildren extends BaseTestCase {
 
   private void init() {
 
-    try (Transaction txn = Ebean.beginTransaction()) {
+    try (Transaction txn = DB.beginTransaction()) {
       String sql;
       SqlUpdate delete;
 
       sql = "delete from td_child";
-      delete = Ebean.createSqlUpdate(sql);
+      delete = DB.sqlUpdate(sql);
       delete.execute();
 
       sql = "delete from td_parent";
-      delete = Ebean.createSqlUpdate(sql);
+      delete = DB.sqlUpdate(sql);
       delete.execute();
 
       EdParent parent = new EdParent();
@@ -34,7 +34,7 @@ public class TestDeleteUnloadedChildren extends BaseTestCase {
       children.add(child);
       parent.setChildren(children);
 
-      Ebean.save(parent);
+      DB.save(parent);
 
       EdExtendedParent extendedParent = new EdExtendedParent();
       extendedParent.setName("My second computer");
@@ -46,7 +46,7 @@ public class TestDeleteUnloadedChildren extends BaseTestCase {
       children.add(child);
       extendedParent.setChildren(children);
 
-      Ebean.save(extendedParent);
+      DB.save(extendedParent);
 
       txn.commit();
     }
@@ -57,11 +57,11 @@ public class TestDeleteUnloadedChildren extends BaseTestCase {
 
     init();
 
-    try (Transaction txn = Ebean.beginTransaction()) {
-      EdParent parent = Ebean.find(EdParent.class).where().eq("name", "MyComputer").findOne();
+    try (Transaction txn = DB.beginTransaction()) {
+      EdParent parent = DB.find(EdParent.class).where().eq("name", "MyComputer").findOne();
       // // Works only if the following statement is included
       // int x = parent.getChildren().size();
-      Ebean.delete(parent);
+      DB.delete(parent);
       txn.commit();
     }
   }
@@ -71,15 +71,15 @@ public class TestDeleteUnloadedChildren extends BaseTestCase {
 
     init();
 
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
-      EdExtendedParent extendedParent = Ebean.find(EdExtendedParent.class).where()
+      EdExtendedParent extendedParent = DB.find(EdExtendedParent.class).where()
         .eq("name", "My second computer").findOne();
       extendedParent.getChildren().size();
-      Ebean.delete(extendedParent);
-      Ebean.commitTransaction();
+      DB.delete(extendedParent);
+      DB.commitTransaction();
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
   }
 
diff --git a/ebean-core/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenFlushThenUpdate.java b/ebean-test/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenFlushThenUpdate.java
similarity index 65%
rename from ebean-core/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenFlushThenUpdate.java
rename to ebean-test/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenFlushThenUpdate.java
index f42b1c2b7..9b9b13028 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenFlushThenUpdate.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenFlushThenUpdate.java
@@ -1,19 +1,17 @@
 package org.tests.model.basic.xtra;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
 
 public class TestInsertBatchThenFlushThenUpdate extends BaseTestCase {
 
@@ -21,8 +19,8 @@ public class TestInsertBatchThenFlushThenUpdate extends BaseTestCase {
   @IgnorePlatform(Platform.HANA)
   public void test() {
 
-    LoggedSqlCollector.start();
-    try (Transaction txn = Ebean.beginTransaction()) {
+    LoggedSql.start();
+    try (Transaction txn = DB.beginTransaction()) {
       txn.setBatchMode(true);
 
       EdParent parent = new EdParent();
@@ -35,26 +33,26 @@ public class TestInsertBatchThenFlushThenUpdate extends BaseTestCase {
       children.add(child);
       parent.setChildren(children);
 
-      Ebean.save(parent);
+      DB.save(parent);
 
       // nothing flushed yet
-      assertThat(LoggedSqlCollector.start()).isEmpty();
+      assertThat(LoggedSql.start()).isEmpty();
 
       txn.flush();
 
-      List<String> loggedSql1 = LoggedSqlCollector.start();
+      List<String> loggedSql1 = LoggedSql.start();
       assertThat(loggedSql1).hasSize(4);
 
       parent.setName("MyDesk");
-      Ebean.save(parent);
+      DB.save(parent);
 
       // nothing flushed yet
-      assertThat(LoggedSqlCollector.start()).isEmpty();
+      assertThat(LoggedSql.start()).isEmpty();
 
-      Ebean.commitTransaction();
+      DB.commitTransaction();
 
       // insert statements for EdExtendedParent
-      List<String> loggedSql2 = LoggedSqlCollector.start();
+      List<String> loggedSql2 = LoggedSql.start();
       assertThat(loggedSql2).hasSize(2);
       assertThat(loggedSql2.get(0)).contains(" update td_parent ");
     }
diff --git a/ebean-core/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenUpdate.java b/ebean-test/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenUpdate.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenUpdate.java
rename to ebean-test/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenUpdate.java
index 7ccd6c4d2..ba3a75ffb 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenUpdate.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/xtra/TestInsertBatchThenUpdate.java
@@ -1,12 +1,12 @@
 package org.tests.model.basic.xtra;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -19,11 +19,11 @@ public class TestInsertBatchThenUpdate extends BaseTestCase {
   @IgnorePlatform({Platform.SQLSERVER, Platform.HANA}) // has generated IDs
   public void test() {
 
-    LoggedSqlCollector.start();
-    try (Transaction txn = Ebean.beginTransaction()) {
+    LoggedSql.start();
+    try (Transaction txn = DB.beginTransaction()) {
       txn.setBatchMode(true);
 
-      LoggedSqlCollector.start();
+      LoggedSql.start();
 
       EdParent parent = new EdParent();
       parent.setName("MyComputer");
@@ -35,19 +35,19 @@ public class TestInsertBatchThenUpdate extends BaseTestCase {
       children.add(child);
       parent.setChildren(children);
 
-      Ebean.save(parent);
+      DB.save(parent);
 
       // get Id or any generated property and that invokes a flush
       parent.getId();
 
       // going to get an update now
       parent.setName("MyDesk");
-      Ebean.save(parent);
+      DB.save(parent);
 
-      Ebean.commitTransaction();
+      DB.commitTransaction();
 
       // insert statements for EdExtendedParent
-      List<String> loggedSql = LoggedSqlCollector.stop();
+      List<String> loggedSql = LoggedSql.stop();
       assertThat(loggedSql).hasSize(6);
       assertThat(loggedSql.get(0)).contains("insert into td_parent");
       assertThat(loggedSql.get(2)).contains("insert into td_child ");
@@ -60,11 +60,11 @@ public class TestInsertBatchThenUpdate extends BaseTestCase {
   @IgnorePlatform(Platform.HANA)
   public void test_noFlushOn_getterOfNonGeneratedProperty() {
 
-    LoggedSqlCollector.start();
-    try (Transaction txn = Ebean.beginTransaction()) {
+    LoggedSql.start();
+    try (Transaction txn = DB.beginTransaction()) {
       txn.setBatchMode(true);
 
-      LoggedSqlCollector.start();
+      LoggedSql.start();
 
       EdParent parent = new EdParent();
       parent.setName("MyComputer");
@@ -76,7 +76,7 @@ public class TestInsertBatchThenUpdate extends BaseTestCase {
       children.add(child);
       parent.setChildren(children);
 
-      Ebean.save(parent);
+      DB.save(parent);
 
       // no getter call on a generated property
       // so no flush here
@@ -84,13 +84,13 @@ public class TestInsertBatchThenUpdate extends BaseTestCase {
 
       parent.setName(existing+" - additional");
       // the first and second save of parent merge into a single insert
-      Ebean.save(parent);
+      DB.save(parent);
 
       // flush
-      Ebean.commitTransaction();
+      DB.commitTransaction();
 
       // insert statements for EdExtendedParent
-      List<String> loggedSql = LoggedSqlCollector.stop();
+      List<String> loggedSql = LoggedSql.stop();
       assertThat(loggedSql).hasSize(4);
       assertThat(loggedSql.get(0)).contains("insert into td_parent");
       assertThat(loggedSql.get(2)).contains("insert into td_child ");
diff --git a/ebean-core/src/test/java/org/tests/model/basic/xtra/TestInsertBatchWithDifferentRootTypes.java b/ebean-test/src/test/java/org/tests/model/basic/xtra/TestInsertBatchWithDifferentRootTypes.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/model/basic/xtra/TestInsertBatchWithDifferentRootTypes.java
rename to ebean-test/src/test/java/org/tests/model/basic/xtra/TestInsertBatchWithDifferentRootTypes.java
index 9bfe75f00..5f1e23178 100644
--- a/ebean-core/src/test/java/org/tests/model/basic/xtra/TestInsertBatchWithDifferentRootTypes.java
+++ b/ebean-test/src/test/java/org/tests/model/basic/xtra/TestInsertBatchWithDifferentRootTypes.java
@@ -1,17 +1,17 @@
 package org.tests.model.basic.xtra;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestInsertBatchWithDifferentRootTypes extends BaseTestCase {
 
@@ -19,9 +19,9 @@ public class TestInsertBatchWithDifferentRootTypes extends BaseTestCase {
   @IgnorePlatform(Platform.HANA)
   public void testDifferRootTypes() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    try (Transaction txn = Ebean.beginTransaction())  {
+    try (Transaction txn = DB.beginTransaction())  {
       txn.setBatchMode(true);
 
       EdParent parent = new EdParent();
@@ -34,7 +34,7 @@ public class TestInsertBatchWithDifferentRootTypes extends BaseTestCase {
       children.add(child);
       parent.setChildren(children);
 
-      Ebean.save(parent);
+      DB.save(parent);
 
       EdExtendedParent extendedParent = new EdExtendedParent();
       extendedParent.setName("My second computer");
@@ -47,22 +47,22 @@ public class TestInsertBatchWithDifferentRootTypes extends BaseTestCase {
       extendedParent.setChildren(children);
 
       // nothing flushed yet
-      List<String> loggedSql0 = LoggedSqlCollector.start();
+      List<String> loggedSql0 = LoggedSql.start();
       assertEquals(0, loggedSql0.size());
 
       // does not causes a flush as EdExtendedParent is same root as EdParent
       // so they get the same batch depth
-      Ebean.save(extendedParent);
+      DB.save(extendedParent);
 
       // insert statements for EdParent
-      List<String> loggedSql1 = LoggedSqlCollector.start();
+      List<String> loggedSql1 = LoggedSql.start();
 
-      Ebean.commitTransaction();
+      DB.commitTransaction();
 
       assertEquals(0, loggedSql1.size());
 
       // insert statements for EdExtendedParent
-      List<String> loggedSql2 = LoggedSqlCollector.start();
+      List<String> loggedSql2 = LoggedSql.start();
       assertEquals(7, loggedSql2.size());
 
     }
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BAccessLevel.java b/ebean-test/src/test/java/org/tests/model/bridge/BAccessLevel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/bridge/BAccessLevel.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BAccessLevel.java
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BDManyId.java b/ebean-test/src/test/java/org/tests/model/bridge/BDManyId.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/bridge/BDManyId.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BDManyId.java
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BEmbId.java b/ebean-test/src/test/java/org/tests/model/bridge/BEmbId.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/bridge/BEmbId.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BEmbId.java
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BSite.java b/ebean-test/src/test/java/org/tests/model/bridge/BSite.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/bridge/BSite.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BSite.java
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BSiteUserA.java b/ebean-test/src/test/java/org/tests/model/bridge/BSiteUserA.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/model/bridge/BSiteUserA.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BSiteUserA.java
index e3c57c10d..f8eb5b2a3 100644
--- a/ebean-core/src/test/java/org/tests/model/bridge/BSiteUserA.java
+++ b/ebean-test/src/test/java/org/tests/model/bridge/BSiteUserA.java
@@ -1,10 +1,6 @@
 package org.tests.model.bridge;
 
-import javax.persistence.Embeddable;
-import javax.persistence.EmbeddedId;
-import javax.persistence.Entity;
-import javax.persistence.ManyToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.Objects;
 import java.util.UUID;
 
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BSiteUserB.java b/ebean-test/src/test/java/org/tests/model/bridge/BSiteUserB.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/bridge/BSiteUserB.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BSiteUserB.java
index ef93cc984..9d4b37f1b 100644
--- a/ebean-core/src/test/java/org/tests/model/bridge/BSiteUserB.java
+++ b/ebean-test/src/test/java/org/tests/model/bridge/BSiteUserB.java
@@ -1,10 +1,6 @@
 package org.tests.model.bridge;
 
-import javax.persistence.Column;
-import javax.persistence.Embeddable;
-import javax.persistence.EmbeddedId;
-import javax.persistence.Entity;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 import java.util.UUID;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BSiteUserC.java b/ebean-test/src/test/java/org/tests/model/bridge/BSiteUserC.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/bridge/BSiteUserC.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BSiteUserC.java
index a23eff0d3..99b3143b7 100644
--- a/ebean-core/src/test/java/org/tests/model/bridge/BSiteUserC.java
+++ b/ebean-test/src/test/java/org/tests/model/bridge/BSiteUserC.java
@@ -1,10 +1,6 @@
 package org.tests.model.bridge;
 
-import javax.persistence.Embeddable;
-import javax.persistence.EmbeddedId;
-import javax.persistence.Entity;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 import java.util.UUID;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BSiteUserD.java b/ebean-test/src/test/java/org/tests/model/bridge/BSiteUserD.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/bridge/BSiteUserD.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BSiteUserD.java
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BSiteUserDMany.java b/ebean-test/src/test/java/org/tests/model/bridge/BSiteUserDMany.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/bridge/BSiteUserDMany.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BSiteUserDMany.java
index 4d7a84f95..ceda12349 100644
--- a/ebean-core/src/test/java/org/tests/model/bridge/BSiteUserDMany.java
+++ b/ebean-test/src/test/java/org/tests/model/bridge/BSiteUserDMany.java
@@ -1,6 +1,9 @@
 package org.tests.model.bridge;
 
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.IdClass;
+import javax.persistence.Version;
 import java.util.UUID;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BSiteUserE.java b/ebean-test/src/test/java/org/tests/model/bridge/BSiteUserE.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/bridge/BSiteUserE.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BSiteUserE.java
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/BUser.java b/ebean-test/src/test/java/org/tests/model/bridge/BUser.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/bridge/BUser.java
rename to ebean-test/src/test/java/org/tests/model/bridge/BUser.java
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/TestExplicitM2MBridgeTable.java b/ebean-test/src/test/java/org/tests/model/bridge/TestExplicitM2MBridgeTable.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/model/bridge/TestExplicitM2MBridgeTable.java
rename to ebean-test/src/test/java/org/tests/model/bridge/TestExplicitM2MBridgeTable.java
index ed22ae4c4..201339bdc 100644
--- a/ebean-core/src/test/java/org/tests/model/bridge/TestExplicitM2MBridgeTable.java
+++ b/ebean-test/src/test/java/org/tests/model/bridge/TestExplicitM2MBridgeTable.java
@@ -1,8 +1,8 @@
 package org.tests.model.bridge;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -16,8 +16,8 @@ public class TestExplicitM2MBridgeTable extends BaseTestCase {
     BUser user = new BUser("Rob");
     BSite site = new BSite("avaje.org");
 
-    Ebean.save(user);
-    Ebean.save(site);
+    DB.save(user);
+    DB.save(site);
 
     insertUpdateBridgeA(user, site);
     insertUpdateBridgeB(user, site);
@@ -30,12 +30,12 @@ public class TestExplicitM2MBridgeTable extends BaseTestCase {
   private void insertUpdateBridgeA(BUser user, BSite site) {
 
     BSiteUserA access = new BSiteUserA(BAccessLevel.ONE, site, user);
-    Ebean.save(access);
+    DB.save(access);
 
     access.setAccessLevel(BAccessLevel.TWO);
-    Ebean.save(access);
+    DB.save(access);
 
-    List<BSiteUserA> list = Ebean.find(BSiteUserA.class).findList();
+    List<BSiteUserA> list = DB.find(BSiteUserA.class).findList();
     assertThat(list).isNotEmpty();
 
     for (BSiteUserA bridge : list) {
@@ -43,10 +43,10 @@ public class TestExplicitM2MBridgeTable extends BaseTestCase {
       assertThat(bridge.getId().userId).isEqualTo(bridge.getUser().id);
     }
 
-    BSiteUserA found = Ebean.find(BSiteUserA.class, new BSiteUserA.Id(site.id, user.id));
+    BSiteUserA found = DB.find(BSiteUserA.class, new BSiteUserA.Id(site.id, user.id));
     found.setAccessLevel(BAccessLevel.THREE);
 
-    Ebean.save(found);
+    DB.save(found);
   }
 
   /**
@@ -55,12 +55,12 @@ public class TestExplicitM2MBridgeTable extends BaseTestCase {
   private void insertUpdateBridgeB(BUser user, BSite site) {
 
     BSiteUserB access = new BSiteUserB(BAccessLevel.ONE, site, user);
-    Ebean.save(access);
+    DB.save(access);
 
     access.setAccessLevel(BAccessLevel.TWO);
-    Ebean.save(access);
+    DB.save(access);
 
-    List<BSiteUserB> list = Ebean.find(BSiteUserB.class).findList();
+    List<BSiteUserB> list = DB.find(BSiteUserB.class).findList();
     assertThat(list).isNotEmpty();
 
     for (BSiteUserB bridge : list) {
@@ -75,12 +75,12 @@ public class TestExplicitM2MBridgeTable extends BaseTestCase {
   private void insertUpdateBridgeC(BUser user, BSite site) {
 
     BSiteUserC access = new BSiteUserC(BAccessLevel.ONE, site, user);
-    Ebean.save(access);
+    DB.save(access);
 
     access.setAccessLevel(BAccessLevel.TWO);
-    Ebean.save(access);
+    DB.save(access);
 
-    List<BSiteUserC> list = Ebean.find(BSiteUserC.class).findList();
+    List<BSiteUserC> list = DB.find(BSiteUserC.class).findList();
     assertThat(list).isNotEmpty();
 
     for (BSiteUserC bridge : list) {
diff --git a/ebean-core/src/test/java/org/tests/model/bridge/TestIdClassScalar.java b/ebean-test/src/test/java/org/tests/model/bridge/TestIdClassScalar.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/bridge/TestIdClassScalar.java
rename to ebean-test/src/test/java/org/tests/model/bridge/TestIdClassScalar.java
index 2e00493fe..78952eb7a 100644
--- a/ebean-core/src/test/java/org/tests/model/bridge/TestIdClassScalar.java
+++ b/ebean-test/src/test/java/org/tests/model/bridge/TestIdClassScalar.java
@@ -2,10 +2,9 @@ package org.tests.model.bridge;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.Transaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.UUID;
@@ -84,8 +83,8 @@ public class TestIdClassScalar extends BaseTestCase {
   @Test
   public void test() {
 
-    Ebean.save(user);
-    Ebean.save(site);
+    DB.save(user);
+    DB.save(site);
 
     insertUpdateBridgeD(user, site);
     insertUpdateBridgeE(user, site);
@@ -96,15 +95,15 @@ public class TestIdClassScalar extends BaseTestCase {
    */
   private void insertUpdateBridgeD(BUser user, BSite site) {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     BSiteUserD access = new BSiteUserD(BAccessLevel.ONE, site.id, user.id);
-    Ebean.save(access);
+    DB.save(access);
 
     access.setAccessLevel(BAccessLevel.TWO);
-    Ebean.save(access);
+    DB.save(access);
 
-    List<BSiteUserD> list = Ebean.find(BSiteUserD.class).findList();
+    List<BSiteUserD> list = DB.find(BSiteUserD.class).findList();
     assertThat(list).isNotEmpty();
 
     for (BSiteUserD bridge : list) {
@@ -112,7 +111,7 @@ public class TestIdClassScalar extends BaseTestCase {
       assertThat(bridge.getUserId()).isEqualTo(user.id);
     }
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("insert into bsite_user_d (site_id, user_id, access_level, version) values (?,?,?,?)");
     assertSql(sql.get(1)).contains("update bsite_user_d set access_level=?, version=? where site_id=? and user_id=? and version=?");
@@ -120,16 +119,16 @@ public class TestIdClassScalar extends BaseTestCase {
 
 
     BEmbId id = new BEmbId(site.id, user.id);
-    BSiteUserD one = Ebean.find(BSiteUserD.class, id);
+    BSiteUserD one = DB.find(BSiteUserD.class, id);
 
     assertThat(one).isNotNull();
     assertThat(one.getSiteId()).isEqualTo(site.id);
     assertThat(one.getUserId()).isEqualTo(user.id);
 
     one.setAccessLevel(BAccessLevel.THREE);
-    Ebean.save(one);
+    DB.save(one);
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.site_id, t0.user_id, t0.site_id, t0.user_id, t0.access_level, t0.version from bsite_user_d t0 where t0.site_id=? and t0.user_id=?");
@@ -141,18 +140,18 @@ public class TestIdClassScalar extends BaseTestCase {
    */
   private void insertUpdateBridgeE(BUser user, BSite site) {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     BSiteUserE access = new BSiteUserE(BAccessLevel.ONE, site, user);
-    Ebean.save(access);
+    DB.save(access);
 
     access.setAccessLevel(BAccessLevel.TWO);
-    Ebean.save(access);
+    DB.save(access);
 
-    List<BSiteUserE> list = Ebean.find(BSiteUserE.class).findList();
+    List<BSiteUserE> list = DB.find(BSiteUserE.class).findList();
     assertThat(list).isNotEmpty();
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("insert into bsite_user_e (site_id, user_id, access_level)");
     assertSql(sql.get(1)).contains("update bsite_user_e set access_level=? where site_id=? and user_id=?");
@@ -166,16 +165,16 @@ public class TestIdClassScalar extends BaseTestCase {
 
     BEmbId id = new BEmbId(site.id, user.id);
 
-    BSiteUserE one = Ebean.find(BSiteUserE.class, id);
+    BSiteUserE one = DB.find(BSiteUserE.class, id);
 
     assertThat(one).isNotNull();
     assertThat(one.getSite().id).isEqualTo(site.id);
     assertThat(one.getUser().id).isEqualTo(user.id);
 
     one.setAccessLevel(BAccessLevel.THREE);
-    Ebean.save(one);
+    DB.save(one);
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.site_id, t0.user_id, t0.access_level, t0.site_id, t0.user_id from bsite_user_e t0 where t0.site_id=? and t0.user_id=?");
diff --git a/ebean-core/src/test/java/org/tests/model/cache/EColAB.java b/ebean-test/src/test/java/org/tests/model/cache/EColAB.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/model/cache/EColAB.java
rename to ebean-test/src/test/java/org/tests/model/cache/EColAB.java
index f3a7377b7..763d70e6c 100644
--- a/ebean-core/src/test/java/org/tests/model/cache/EColAB.java
+++ b/ebean-test/src/test/java/org/tests/model/cache/EColAB.java
@@ -13,7 +13,7 @@ import javax.persistence.Table;
 public class EColAB extends Model {
 
   @Id
-  private Long id;
+  private Integer id;
 
   private String columnA;
 
@@ -24,11 +24,11 @@ public class EColAB extends Model {
     this.columnB = columnB;
   }
 
-  public Long getId() {
+  public Integer getId() {
     return id;
   }
 
-  public void setId(Long id) {
+  public void setId(Integer id) {
     this.id = id;
   }
 
diff --git a/ebean-core/src/test/java/org/tests/model/cache/M2MCacheChild.java b/ebean-test/src/test/java/org/tests/model/cache/M2MCacheChild.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/cache/M2MCacheChild.java
rename to ebean-test/src/test/java/org/tests/model/cache/M2MCacheChild.java
index d40b26a63..07b3b9a91 100644
--- a/ebean-core/src/test/java/org/tests/model/cache/M2MCacheChild.java
+++ b/ebean-test/src/test/java/org/tests/model/cache/M2MCacheChild.java
@@ -1,10 +1,10 @@
 package org.tests.model.cache;
 
+import io.ebean.annotation.Cache;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 
-import io.ebean.annotation.Cache;
-
 @Entity
 @Cache(enableQueryCache = true, enableBeanCache = true)
 public class M2MCacheChild {
@@ -30,4 +30,4 @@ public class M2MCacheChild {
     this.name = name;
   }
 
-}
\ No newline at end of file
+}
diff --git a/ebean-core/src/test/java/org/tests/model/cache/M2MCacheMaster.java b/ebean-test/src/test/java/org/tests/model/cache/M2MCacheMaster.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/cache/M2MCacheMaster.java
rename to ebean-test/src/test/java/org/tests/model/cache/M2MCacheMaster.java
index 5eedc2994..d422eb5a4 100644
--- a/ebean-core/src/test/java/org/tests/model/cache/M2MCacheMaster.java
+++ b/ebean-test/src/test/java/org/tests/model/cache/M2MCacheMaster.java
@@ -1,16 +1,11 @@
 package org.tests.model.cache;
 
+import io.ebean.annotation.Cache;
+
+import javax.persistence.*;
 import java.util.LinkedHashSet;
 import java.util.Set;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
-
-import io.ebean.annotation.Cache;
-
 @Entity
 @Cache(enableQueryCache = true, enableBeanCache = true)
 public class M2MCacheMaster {
diff --git a/ebean-core/src/test/java/org/tests/model/carwheel/Car.java b/ebean-test/src/test/java/org/tests/model/carwheel/Car.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/carwheel/Car.java
rename to ebean-test/src/test/java/org/tests/model/carwheel/Car.java
index 65981f46b..7da07463b 100644
--- a/ebean-core/src/test/java/org/tests/model/carwheel/Car.java
+++ b/ebean-test/src/test/java/org/tests/model/carwheel/Car.java
@@ -2,14 +2,7 @@ package org.tests.model.carwheel;
 
 import io.ebean.annotation.Aggregation;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/carwheel/Tire.java b/ebean-test/src/test/java/org/tests/model/carwheel/Tire.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/model/carwheel/Tire.java
rename to ebean-test/src/test/java/org/tests/model/carwheel/Tire.java
index 9561cb796..886ea8d53 100644
--- a/ebean-core/src/test/java/org/tests/model/carwheel/Tire.java
+++ b/ebean-test/src/test/java/org/tests/model/carwheel/Tire.java
@@ -1,11 +1,6 @@
 package org.tests.model.carwheel;
 
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "sa_tire")
diff --git a/ebean-core/src/test/java/org/tests/model/carwheel/Wheel.java b/ebean-test/src/test/java/org/tests/model/carwheel/Wheel.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/model/carwheel/Wheel.java
rename to ebean-test/src/test/java/org/tests/model/carwheel/Wheel.java
index 3390f6dd4..402f90788 100644
--- a/ebean-core/src/test/java/org/tests/model/carwheel/Wheel.java
+++ b/ebean-test/src/test/java/org/tests/model/carwheel/Wheel.java
@@ -1,14 +1,6 @@
 package org.tests.model.carwheel;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "sa_wheel")
diff --git a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TCar.java b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TCar.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/model/carwheeltruck/TCar.java
rename to ebean-test/src/test/java/org/tests/model/carwheeltruck/TCar.java
index 988ab4666..3479c3a65 100644
--- a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TCar.java
+++ b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TCar.java
@@ -2,15 +2,7 @@ package org.tests.model.carwheeltruck;
 
 import io.ebean.annotation.SoftDelete;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.OneToMany;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TTruck.java b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TTruck.java
similarity index 60%
rename from ebean-core/src/test/java/org/tests/model/carwheeltruck/TTruck.java
rename to ebean-test/src/test/java/org/tests/model/carwheeltruck/TTruck.java
index 86529a19c..746a2233b 100644
--- a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TTruck.java
+++ b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TTruck.java
@@ -1,11 +1,6 @@
 package org.tests.model.carwheeltruck;
 
-import javax.persistence.Column;
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
+import javax.persistence.*;
 
 @Entity
 @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
diff --git a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TTruckHolder.java b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TTruckHolder.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/carwheeltruck/TTruckHolder.java
rename to ebean-test/src/test/java/org/tests/model/carwheeltruck/TTruckHolder.java
index 74f9e8248..d9f917421 100644
--- a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TTruckHolder.java
+++ b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TTruckHolder.java
@@ -2,11 +2,7 @@ package org.tests.model.carwheeltruck;
 
 import org.tests.model.basic.EBasic;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 import static javax.persistence.CascadeType.ALL;
diff --git a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TTruckHolderItem.java b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TTruckHolderItem.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/carwheeltruck/TTruckHolderItem.java
rename to ebean-test/src/test/java/org/tests/model/carwheeltruck/TTruckHolderItem.java
diff --git a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TWheel.java b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TWheel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/carwheeltruck/TWheel.java
rename to ebean-test/src/test/java/org/tests/model/carwheeltruck/TWheel.java
diff --git a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TestInheritSoftDeleteJoin.java b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TestInheritSoftDeleteJoin.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/model/carwheeltruck/TestInheritSoftDeleteJoin.java
rename to ebean-test/src/test/java/org/tests/model/carwheeltruck/TestInheritSoftDeleteJoin.java
index b7d4b3970..772d12c5b 100644
--- a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TestInheritSoftDeleteJoin.java
+++ b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TestInheritSoftDeleteJoin.java
@@ -2,8 +2,8 @@ package org.tests.model.carwheeltruck;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebeantest.LoggedSql;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TestMTOInheritNoDiscriminator.java b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TestMTOInheritNoDiscriminator.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/model/carwheeltruck/TestMTOInheritNoDiscriminator.java
rename to ebean-test/src/test/java/org/tests/model/carwheeltruck/TestMTOInheritNoDiscriminator.java
index 62ed889d4..81a13c894 100644
--- a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TestMTOInheritNoDiscriminator.java
+++ b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TestMTOInheritNoDiscriminator.java
@@ -2,8 +2,8 @@ package org.tests.model.carwheeltruck;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -16,7 +16,7 @@ public class TestMTOInheritNoDiscriminator extends BaseTestCase {
 
     final TTruckHolder holder = setup();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     final TTruckHolder found = DB.find(TTruckHolder.class)
       .fetch("items")
@@ -27,7 +27,7 @@ public class TestMTOInheritNoDiscriminator extends BaseTestCase {
     assertThat(found.getItems()).hasSize(2);
     assertThat(found.getItems()).extracting(TTruckHolderItem::getFoo).contains("a","b");
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(1);
     if (isH2() || isPostgres()) {
diff --git a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TestTruckCarWheelInhertiance.java b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TestTruckCarWheelInhertiance.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/carwheeltruck/TestTruckCarWheelInhertiance.java
rename to ebean-test/src/test/java/org/tests/model/carwheeltruck/TestTruckCarWheelInhertiance.java
index 179754200..18ed6d523 100644
--- a/ebean-core/src/test/java/org/tests/model/carwheeltruck/TestTruckCarWheelInhertiance.java
+++ b/ebean-test/src/test/java/org/tests/model/carwheeltruck/TestTruckCarWheelInhertiance.java
@@ -1,8 +1,8 @@
 package org.tests.model.carwheeltruck;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import java.util.Random;
 
@@ -17,7 +17,7 @@ public class TestTruckCarWheelInhertiance extends BaseTestCase {
     TWheel wheel = new TWheel();
     wheel.setOwner(truck);
 
-    Ebean.save(truck);
+    DB.save(truck);
 
     // This save() works ok...
 
@@ -26,7 +26,7 @@ public class TestTruckCarWheelInhertiance extends BaseTestCase {
     wheel.setOwner(truck);
 
     // And save() is called again
-    Ebean.save(truck);
+    DB.save(truck);
 
     // Then an exception is raised:
   }
diff --git a/ebean-core/src/test/java/org/tests/model/composite/CkeClient.java b/ebean-test/src/test/java/org/tests/model/composite/CkeClient.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/model/composite/CkeClient.java
rename to ebean-test/src/test/java/org/tests/model/composite/CkeClient.java
index 59cd53edb..d19b742db 100644
--- a/ebean-core/src/test/java/org/tests/model/composite/CkeClient.java
+++ b/ebean-test/src/test/java/org/tests/model/composite/CkeClient.java
@@ -1,11 +1,6 @@
 package org.tests.model.composite;
 
-import javax.persistence.EmbeddedId;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinColumns;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 
 @Entity
 public class CkeClient {
diff --git a/ebean-core/src/test/java/org/tests/model/composite/CkeClientKey.java b/ebean-test/src/test/java/org/tests/model/composite/CkeClientKey.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/composite/CkeClientKey.java
rename to ebean-test/src/test/java/org/tests/model/composite/CkeClientKey.java
index 2d4456ce9..4a897c1b6 100644
--- a/ebean-core/src/test/java/org/tests/model/composite/CkeClientKey.java
+++ b/ebean-test/src/test/java/org/tests/model/composite/CkeClientKey.java
@@ -4,7 +4,6 @@ import javax.persistence.Basic;
 import javax.persistence.Column;
 import javax.persistence.Embeddable;
 import javax.validation.constraints.Size;
-
 import java.util.Objects;
 
 @Embeddable
diff --git a/ebean-core/src/test/java/org/tests/model/composite/CkeUser.java b/ebean-test/src/test/java/org/tests/model/composite/CkeUser.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/composite/CkeUser.java
rename to ebean-test/src/test/java/org/tests/model/composite/CkeUser.java
diff --git a/ebean-core/src/test/java/org/tests/model/composite/CkeUserKey.java b/ebean-test/src/test/java/org/tests/model/composite/CkeUserKey.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/composite/CkeUserKey.java
rename to ebean-test/src/test/java/org/tests/model/composite/CkeUserKey.java
index 09939ead3..de55f7c1a 100644
--- a/ebean-core/src/test/java/org/tests/model/composite/CkeUserKey.java
+++ b/ebean-test/src/test/java/org/tests/model/composite/CkeUserKey.java
@@ -4,7 +4,6 @@ import javax.persistence.Basic;
 import javax.persistence.Column;
 import javax.persistence.Embeddable;
 import javax.validation.constraints.Size;
-
 import java.util.Objects;
 
 @Embeddable
diff --git a/ebean-core/src/test/java/org/tests/model/composite/RCustomer.java b/ebean-test/src/test/java/org/tests/model/composite/RCustomer.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/composite/RCustomer.java
rename to ebean-test/src/test/java/org/tests/model/composite/RCustomer.java
diff --git a/ebean-core/src/test/java/org/tests/model/composite/RCustomerKey.java b/ebean-test/src/test/java/org/tests/model/composite/RCustomerKey.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/composite/RCustomerKey.java
rename to ebean-test/src/test/java/org/tests/model/composite/RCustomerKey.java
diff --git a/ebean-core/src/test/java/org/tests/model/composite/ROrder.java b/ebean-test/src/test/java/org/tests/model/composite/ROrder.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/composite/ROrder.java
rename to ebean-test/src/test/java/org/tests/model/composite/ROrder.java
index 0b543321a..b5b48bcd9 100644
--- a/ebean-core/src/test/java/org/tests/model/composite/ROrder.java
+++ b/ebean-test/src/test/java/org/tests/model/composite/ROrder.java
@@ -1,13 +1,6 @@
 package org.tests.model.composite;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.EmbeddedId;
-import javax.persistence.Entity;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinColumns;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
 
 
diff --git a/ebean-core/src/test/java/org/tests/model/composite/ROrderPK.java b/ebean-test/src/test/java/org/tests/model/composite/ROrderPK.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/composite/ROrderPK.java
rename to ebean-test/src/test/java/org/tests/model/composite/ROrderPK.java
diff --git a/ebean-core/src/test/java/org/tests/model/composite/TestCompositeKeyUserClient.java b/ebean-test/src/test/java/org/tests/model/composite/TestCompositeKeyUserClient.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/model/composite/TestCompositeKeyUserClient.java
rename to ebean-test/src/test/java/org/tests/model/composite/TestCompositeKeyUserClient.java
index 3499c5162..57b3bf6d8 100644
--- a/ebean-core/src/test/java/org/tests/model/composite/TestCompositeKeyUserClient.java
+++ b/ebean-test/src/test/java/org/tests/model/composite/TestCompositeKeyUserClient.java
@@ -1,9 +1,9 @@
 package org.tests.model.composite;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -17,34 +17,34 @@ public class TestCompositeKeyUserClient extends BaseTestCase {
     CkeUser user0 = new CkeUser();
     user0.setUserPK(new CkeUserKey(20, "sally"));
     user0.setName("sally");
-    Ebean.save(user0);
+    DB.save(user0);
 
     CkeUser user1 = new CkeUser();
     user1.setUserPK(new CkeUserKey(20, "frank"));
     user1.setName("hello");
-    Ebean.save(user1);
+    DB.save(user1);
 
     CkeClient client = new CkeClient();
     client.setNotes("try it");
     client.setClientPK(new CkeClientKey(20, "susan"));
     client.setUser(user1);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.save(client);
+    DB.save(client);
 
     client.setNotes("update it");
     client.setUser(user0);
 
-    Ebean.save(client);
+    DB.save(client);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("insert into cke_client (cod_cpny, cod_client, notes, username) values (?,?,?,?)");
     assertSql(sql.get(1)).contains("update cke_client set notes=?, username=? where cod_cpny=? and cod_client=?");
 
-    Ebean.delete(client);
+    DB.delete(client);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/converstation/Conversation.java b/ebean-test/src/test/java/org/tests/model/converstation/Conversation.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/converstation/Conversation.java
rename to ebean-test/src/test/java/org/tests/model/converstation/Conversation.java
index 7fe9bcfdf..0caada259 100644
--- a/ebean-core/src/test/java/org/tests/model/converstation/Conversation.java
+++ b/ebean-test/src/test/java/org/tests/model/converstation/Conversation.java
@@ -3,11 +3,7 @@ package org.tests.model.converstation;
 import io.ebean.annotation.FetchPreference;
 import org.tests.model.BaseModel;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/converstation/Group.java b/ebean-test/src/test/java/org/tests/model/converstation/Group.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/converstation/Group.java
rename to ebean-test/src/test/java/org/tests/model/converstation/Group.java
diff --git a/ebean-core/src/test/java/org/tests/model/converstation/Message.java b/ebean-test/src/test/java/org/tests/model/converstation/Message.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/converstation/Message.java
rename to ebean-test/src/test/java/org/tests/model/converstation/Message.java
diff --git a/ebean-core/src/test/java/org/tests/model/converstation/Participation.java b/ebean-test/src/test/java/org/tests/model/converstation/Participation.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/converstation/Participation.java
rename to ebean-test/src/test/java/org/tests/model/converstation/Participation.java
diff --git a/ebean-core/src/test/java/org/tests/model/converstation/User.java b/ebean-test/src/test/java/org/tests/model/converstation/User.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/converstation/User.java
rename to ebean-test/src/test/java/org/tests/model/converstation/User.java
diff --git a/ebean-core/src/test/java/org/tests/model/ddd/DExhEntity.java b/ebean-test/src/test/java/org/tests/model/ddd/DExhEntity.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ddd/DExhEntity.java
rename to ebean-test/src/test/java/org/tests/model/ddd/DExhEntity.java
diff --git a/ebean-core/src/test/java/org/tests/model/ddd/DPerson.java b/ebean-test/src/test/java/org/tests/model/ddd/DPerson.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ddd/DPerson.java
rename to ebean-test/src/test/java/org/tests/model/ddd/DPerson.java
diff --git a/ebean-core/src/test/java/org/tests/model/ddd/TestScalarTypeConverter.java b/ebean-test/src/test/java/org/tests/model/ddd/TestScalarTypeConverter.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/ddd/TestScalarTypeConverter.java
rename to ebean-test/src/test/java/org/tests/model/ddd/TestScalarTypeConverter.java
index dec65742a..eaf5ad37a 100644
--- a/ebean-core/src/test/java/org/tests/model/ddd/TestScalarTypeConverter.java
+++ b/ebean-test/src/test/java/org/tests/model/ddd/TestScalarTypeConverter.java
@@ -1,7 +1,7 @@
 package org.tests.model.ddd;
 
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.ivo.Oid;
 import org.tests.model.ivo.converter.AnEnumType;
 
@@ -16,9 +16,9 @@ public class TestScalarTypeConverter {
     exhEntity.setOid(new Oid<>(12));
     exhEntity.setAnEnumType(AnEnumType.ONE);
 
-    Ebean.save(exhEntity);
+    DB.save(exhEntity);
 
-    int count = Ebean.find(DExhEntity.class)
+    int count = DB.find(DExhEntity.class)
       .where().eq("anEnumType", AnEnumType.ONE)
       .findCount();
 
diff --git a/ebean-core/src/test/java/org/tests/model/docstore/CustomerReport.java b/ebean-test/src/test/java/org/tests/model/docstore/CustomerReport.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/docstore/CustomerReport.java
rename to ebean-test/src/test/java/org/tests/model/docstore/CustomerReport.java
index 74ffb0e92..4deef720b 100644
--- a/ebean-core/src/test/java/org/tests/model/docstore/CustomerReport.java
+++ b/ebean-test/src/test/java/org/tests/model/docstore/CustomerReport.java
@@ -1,18 +1,16 @@
 package org.tests.model.docstore;
 
-import java.util.List;
+import io.ebean.annotation.DocStore;
+import org.tests.model.basic.Customer;
 
 import javax.persistence.DiscriminatorValue;
 import javax.persistence.ManyToOne;
 import javax.persistence.OneToMany;
-
-import org.tests.model.basic.Customer;
-
-import io.ebean.annotation.DocStore;
+import java.util.List;
 
 /**
  * Entity that will stored as JSON in database
- * 
+ *
  * @author Roland Praml, FOCONIS AG
  *
  */
diff --git a/ebean-core/src/test/java/org/tests/model/docstore/ProductReport.java b/ebean-test/src/test/java/org/tests/model/docstore/ProductReport.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/docstore/ProductReport.java
rename to ebean-test/src/test/java/org/tests/model/docstore/ProductReport.java
index 605ccde9a..194fa8385 100644
--- a/ebean-core/src/test/java/org/tests/model/docstore/ProductReport.java
+++ b/ebean-test/src/test/java/org/tests/model/docstore/ProductReport.java
@@ -1,19 +1,18 @@
 package org.tests.model.docstore;
 
+import io.ebean.annotation.DocStore;
+import org.tests.model.basic.Product;
+
 import javax.persistence.DiscriminatorValue;
 import javax.persistence.ManyToOne;
 
-import org.tests.model.basic.Product;
-
-import io.ebean.annotation.DocStore;
-
 @DocStore
 @DiscriminatorValue("PR")
 public class ProductReport extends Report {
 
   @ManyToOne
   private Product product;
-  
+
   public Product getProduct() {
     return product;
   }
diff --git a/ebean-core/src/test/java/org/tests/model/docstore/Report.java b/ebean-test/src/test/java/org/tests/model/docstore/Report.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/model/docstore/Report.java
rename to ebean-test/src/test/java/org/tests/model/docstore/Report.java
index cefcbce10..707a56bd8 100644
--- a/ebean-core/src/test/java/org/tests/model/docstore/Report.java
+++ b/ebean-test/src/test/java/org/tests/model/docstore/Report.java
@@ -1,32 +1,31 @@
 package org.tests.model.docstore;
 
-import java.util.List;
+import io.ebean.annotation.DocStore;
 
 import javax.persistence.Inheritance;
 import javax.persistence.OneToMany;
-
-import io.ebean.annotation.DocStore;
+import java.util.List;
 
 @DocStore
 @Inheritance
 public class Report {
   private String title;
-  
+
   @OneToMany
   private List<Report> embeddedReports;
-  
+
   public void setTitle(String title) {
     this.title = title;
   }
-  
+
   public String getTitle() {
     return title;
   }
-  
+
   public List<Report> getEmbeddedReports() {
     return embeddedReports;
   }
-  
+
   public void setEmbeddedReports(List<Report> embeddedReports) {
     this.embeddedReports = embeddedReports;
   }
diff --git a/ebean-core/src/test/java/org/tests/model/draftable/BaseDomain.java b/ebean-test/src/test/java/org/tests/model/draftable/BaseDomain.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/draftable/BaseDomain.java
rename to ebean-test/src/test/java/org/tests/model/draftable/BaseDomain.java
diff --git a/ebean-core/src/test/java/org/tests/model/draftable/BasicDraftableBean.java b/ebean-test/src/test/java/org/tests/model/draftable/BasicDraftableBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/draftable/BasicDraftableBean.java
rename to ebean-test/src/test/java/org/tests/model/draftable/BasicDraftableBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/draftable/Doc.java b/ebean-test/src/test/java/org/tests/model/draftable/Doc.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/draftable/Doc.java
rename to ebean-test/src/test/java/org/tests/model/draftable/Doc.java
diff --git a/ebean-core/src/test/java/org/tests/model/draftable/Document.java b/ebean-test/src/test/java/org/tests/model/draftable/Document.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/draftable/Document.java
rename to ebean-test/src/test/java/org/tests/model/draftable/Document.java
diff --git a/ebean-core/src/test/java/org/tests/model/draftable/DocumentMedia.java b/ebean-test/src/test/java/org/tests/model/draftable/DocumentMedia.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/draftable/DocumentMedia.java
rename to ebean-test/src/test/java/org/tests/model/draftable/DocumentMedia.java
diff --git a/ebean-core/src/test/java/org/tests/model/draftable/Link.java b/ebean-test/src/test/java/org/tests/model/draftable/Link.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/draftable/Link.java
rename to ebean-test/src/test/java/org/tests/model/draftable/Link.java
index 956282059..547f3012b 100644
--- a/ebean-core/src/test/java/org/tests/model/draftable/Link.java
+++ b/ebean-test/src/test/java/org/tests/model/draftable/Link.java
@@ -1,11 +1,6 @@
 package org.tests.model.draftable;
 
-import io.ebean.annotation.Draft;
-import io.ebean.annotation.DraftDirty;
-import io.ebean.annotation.DraftReset;
-import io.ebean.annotation.Draftable;
-import io.ebean.annotation.History;
-import io.ebean.annotation.SoftDelete;
+import io.ebean.annotation.*;
 
 import javax.persistence.Column;
 import javax.persistence.Entity;
diff --git a/ebean-core/src/test/java/org/tests/model/draftable/Organisation.java b/ebean-test/src/test/java/org/tests/model/draftable/Organisation.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/draftable/Organisation.java
rename to ebean-test/src/test/java/org/tests/model/draftable/Organisation.java
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcEnumPerson.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcEnumPerson.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcEnumPerson.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcEnumPerson.java
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcPerson.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcPerson.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcPerson.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcPerson.java
index 763b137ab..c41a7540a 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcPerson.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcPerson.java
@@ -2,13 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.CollectionTable;
-import javax.persistence.Column;
-import javax.persistence.ElementCollection;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcPersonPersistAdapter.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcPersonPersistAdapter.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcPersonPersistAdapter.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcPersonPersistAdapter.java
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcPhone.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcPhone.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcPhone.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcPhone.java
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcTop.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcTop.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcTop.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcTop.java
index 29f82cb41..de38b9a11 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcTop.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcTop.java
@@ -1,10 +1,6 @@
 package org.tests.model.elementcollection;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToMany;
-import javax.persistence.ManyToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 import static javax.persistence.CascadeType.ALL;
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcblPerson.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcblPerson.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcblPerson.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcblPerson.java
index c4998d855..03b6cb086 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcblPerson.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcblPerson.java
@@ -2,12 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.CollectionTable;
-import javax.persistence.ElementCollection;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcbmPerson.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcbmPerson.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcbmPerson.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcbmPerson.java
index 992178c54..b4e2b70d1 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcbmPerson.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcbmPerson.java
@@ -2,12 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.CollectionTable;
-import javax.persistence.ElementCollection;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcmPerson.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcmPerson.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcmPerson.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcmPerson.java
index 8bd280ea1..2dad35c3c 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcmPerson.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcmPerson.java
@@ -2,14 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.Column;
-import javax.persistence.ElementCollection;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.MapKeyColumn;
-import javax.persistence.Transient;
-import javax.persistence.Version;
-
+import javax.persistence.*;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcmPersonTest.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcmPersonTest.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcmPersonTest.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcmPersonTest.java
index dc50fe412..b3b505068 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcmPersonTest.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcmPersonTest.java
@@ -3,9 +3,9 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
+import io.ebean.test.LoggedSql;
 import io.ebean.text.json.JsonContext;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -25,11 +25,11 @@ public class EcmPersonTest extends BaseTestCase {
 
     final EcmPerson person = json.toBean(EcmPerson.class, asJson);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.save(person);
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(4);
     assertSql(sql.get(0)).contains("insert into ecm_person ");
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcmcPerson.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcmcPerson.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcmcPerson.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcmcPerson.java
index fe7d326e6..d89cbc311 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcmcPerson.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcmcPerson.java
@@ -2,12 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.ElementCollection;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Lob;
-import javax.persistence.MapKeyColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsPerson.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsPerson.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcsPerson.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcsPerson.java
index f0c854db7..d6661f1e2 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsPerson.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsPerson.java
@@ -1,11 +1,6 @@
 package org.tests.model.elementcollection;
 
-import javax.persistence.CollectionTable;
-import javax.persistence.Column;
-import javax.persistence.ElementCollection;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.LinkedHashSet;
 import java.util.Set;
 
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsPersonTest.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsPersonTest.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcsPersonTest.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcsPersonTest.java
index df763beaf..44bd1d576 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsPersonTest.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsPersonTest.java
@@ -2,9 +2,9 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
+import io.ebean.test.LoggedSql;
 import io.ebean.text.json.JsonContext;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -24,11 +24,11 @@ public class EcsPersonTest extends BaseTestCase {
 
     final EcsPerson person = json.toBean(EcsPerson.class, asJson);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.save(person);
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(4);
     assertSql(sql.get(0)).contains("insert into ecs_person ");
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsmChild.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsmChild.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcsmChild.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcsmChild.java
index 5299f4dca..6cf06f282 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsmChild.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsmChild.java
@@ -1,11 +1,6 @@
 package org.tests.model.elementcollection;
 
-import javax.persistence.CollectionTable;
-import javax.persistence.ElementCollection;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.UUID;
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsmOne.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsmOne.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcsmOne.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcsmOne.java
index 58f3ec21b..750512cc7 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsmOne.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsmOne.java
@@ -1,11 +1,6 @@
 package org.tests.model.elementcollection;
 
-import javax.persistence.CollectionTable;
-import javax.persistence.ElementCollection;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.UUID;
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsmParent.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsmParent.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcsmParent.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcsmParent.java
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsmTwo.java b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsmTwo.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/EcsmTwo.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/EcsmTwo.java
index 084a8f1a7..0f3cb85a1 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/EcsmTwo.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/EcsmTwo.java
@@ -1,11 +1,6 @@
 package org.tests.model.elementcollection;
 
-import javax.persistence.CollectionTable;
-import javax.persistence.ElementCollection;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.UUID;
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasic.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasic.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasic.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasic.java
index 78562fb6d..b214a3381 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasic.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasic.java
@@ -1,10 +1,10 @@
 package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -23,29 +23,29 @@ public class TestElementCollectionBasic extends BaseTestCase {
     person.getPhoneNumbers().add("021 1234");
     person.getPhoneNumbers().add("021 4321");
 
-    LoggedSqlCollector.start();
-    Ebean.save(person);
+    LoggedSql.start();
+    DB.save(person);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(eventLog()).containsOnly("preInsert", "postInsert");
     assertThat(sql).hasSize(4);
 
-    final EcPerson found = Ebean.find(EcPerson.class)
+    final EcPerson found = DB.find(EcPerson.class)
       .setId(person.getId())
       //.setLabel("findById")
       .findOne();
 
     found.getPhoneNumbers().size();
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("from ec_person t0 where t0.id = ?");
     assertSql(sql.get(1)).contains("from ec_person_phone t0 where");
 
     // save when not actually changed
-    Ebean.save(found);
+    DB.save(found);
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).isEmpty();
     assertThat(eventLog()).isEmpty();
   }
@@ -54,16 +54,16 @@ public class TestElementCollectionBasic extends BaseTestCase {
   public void test() {
 
     eventLog();
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     EcPerson person = new EcPerson("Fiona021");
     person.getPhoneNumbers().add("021 1234");
     person.getPhoneNumbers().add("021 4321");
-    Ebean.save(person);
+    DB.save(person);
 
     assertThat(eventLog()).containsExactly("preInsert", "postInsert");
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(4);
       assertSql(sql.get(0)).contains("insert into ec_person");
@@ -79,14 +79,14 @@ public class TestElementCollectionBasic extends BaseTestCase {
     EcPerson person1 = new EcPerson("Fiona09");
     person1.getPhoneNumbers().add("09 1234");
     person1.getPhoneNumbers().add("09 4321");
-    Ebean.save(person1);
+    DB.save(person1);
 
     assertThat(eventLog()).containsExactly("preInsert", "postInsert");
 
-    LoggedSqlCollector.current();
+    LoggedSql.collect();
 
     List<EcPerson> found =
-      Ebean.find(EcPerson.class).where()
+      DB.find(EcPerson.class).where()
         .startsWith("name", "Fiona0")
         .order().asc("id")
         .findList();
@@ -98,13 +98,13 @@ public class TestElementCollectionBasic extends BaseTestCase {
     assertThat(phoneNumbers0).containsExactly("021 1234", "021 4321");
     assertThat(phoneNumbers1).containsExactly("09 1234", "09 4321");
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t0.version from ec_person t0 where");
     assertSql(sql.get(1)).contains("select t0.owner_id, t0.phone from ec_person_phone t0 where");
 
     List<EcPerson> found2 =
-      Ebean.find(EcPerson.class)
+      DB.find(EcPerson.class)
         .fetch("phoneNumbers")
         .where()
         .startsWith("name", "Fiona0")
@@ -113,7 +113,7 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
     assertThat(found2).hasSize(2);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t0.version, t1.phone from ec_person t0 left join ec_person_phone t1");
 
@@ -122,15 +122,15 @@ public class TestElementCollectionBasic extends BaseTestCase {
     jsonToFrom(foundFirst);
     updateBasic(foundFirst);
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 
   private void updateBasic(EcPerson bean) {
 
     bean.setName("Fiona021-mod-0");
-    Ebean.save(bean);
+    DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("update ec_person");
 
@@ -141,14 +141,14 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
   private void updateBasicInBatch(EcPerson bean) {
 
-    try (Transaction txn = Ebean.beginTransaction()) {
+    try (Transaction txn = DB.beginTransaction()) {
       txn.setBatchMode(true);
       bean.setName("Fiona021-mod-0-batch");
-      Ebean.save(bean);
+      DB.save(bean);
       txn.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("update ec_person");
 
@@ -161,9 +161,9 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
     bean.setName("Fiona021-mod-both");
     bean.getPhoneNumbers().add("01-22123");
-    Ebean.save(bean);
+    DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSql(sql.get(0)).contains("update ec_person set name=?, version=? where id=? and version=?");
@@ -188,15 +188,15 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
   private void updateBothInBatch(EcPerson bean) {
 
-    try (Transaction txn = Ebean.beginTransaction()) {
+    try (Transaction txn = DB.beginTransaction()) {
       txn.setBatchMode(true);
       bean.setName("Fiona021-mod-both-batch");
       bean.getPhoneNumbers().add("01-22123");
-      Ebean.save(bean);
+      DB.save(bean);
       txn.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(9);
     assertSql(sql.get(0)).contains("update ec_person set name=?, version=? where id=? and version=?");
     assertSql(sql.get(2)).contains("delete from ec_person_phone where owner_id=?");
@@ -211,9 +211,9 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
   private void updateNothing(EcPerson bean) {
 
-    Ebean.save(bean);
+    DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(0);
 
     assertThat(eventLog()).isEmpty();
@@ -223,14 +223,14 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
   private void updateOnlyCollectionInBatch(EcPerson bean) {
 
-    try (Transaction txn = Ebean.beginTransaction()) {
+    try (Transaction txn = DB.beginTransaction()) {
       txn.setBatchMode(true);
       bean.getPhoneNumbers().add("01-4321");
-      Ebean.save(bean);
+      DB.save(bean);
       txn.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(8);
     assertSql(sql.get(0)).contains("delete from ec_person_phone where owner_id=?");
     assertSqlBind(sql, 1);
@@ -245,9 +245,9 @@ public class TestElementCollectionBasic extends BaseTestCase {
   private void updateOnlyCollection(EcPerson bean) {
 
     bean.getPhoneNumbers().add("01-4321");
-    Ebean.save(bean);
+    DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(9);
       assertSql(sql.get(0)).contains("delete from ec_person_phone where owner_id=?");
@@ -273,9 +273,9 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
   private void delete(EcPerson bean) {
 
-    Ebean.delete(bean);
+    DB.delete(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from ec_person_phone where owner_id = ?");
     assertSql(sql.get(1)).contains("delete from ec_person where id=? and version=?");
@@ -285,8 +285,8 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
   private void jsonToFrom(EcPerson foundFirst) {
 
-    String asJson = Ebean.json().toJson(foundFirst);
-    EcPerson fromJson = Ebean.json().toBean(EcPerson.class, asJson);
+    String asJson = DB.json().toJson(foundFirst);
+    EcPerson fromJson = DB.json().toBean(EcPerson.class, asJson);
     assertThat(fromJson.getPhoneNumbers()).containsAll(foundFirst.getPhoneNumbers());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicCache.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicCache.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicCache.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicCache.java
index eaebe3f78..3fa8ac694 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicCache.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicCache.java
@@ -1,11 +1,11 @@
 package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.PersistBatch;
+import io.ebean.test.LoggedSql;
 import io.ebeaninternal.api.SpiEbeanServer;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -19,29 +19,29 @@ public class TestElementCollectionBasicCache extends BaseTestCase {
     EcPerson person = new EcPerson("Cache1");
     person.getPhoneNumbers().add("021 1234");
     person.getPhoneNumbers().add("021 4321");
-    Ebean.save(person);
+    DB.save(person);
 
-    EcPerson one = Ebean.find(EcPerson.class)
+    EcPerson one = DB.find(EcPerson.class)
       .setId(person.getId())
       .findOne();
 
     one.getPhoneNumbers().size();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    EcPerson two = Ebean.find(EcPerson.class)
+    EcPerson two = DB.find(EcPerson.class)
       .setId(person.getId())
       .findOne();
 
     two.setName("CacheMod");
     two.getPhoneNumbers().add("027 234234");
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // cache hit containing phone numbers
 
-    Ebean.save(two);
+    DB.save(two);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSqlBind(sql, 4, 6);
@@ -49,32 +49,32 @@ public class TestElementCollectionBasicCache extends BaseTestCase {
       assertThat(sql).hasSize(5);
     }
 
-    Ebean.save(two);
+    DB.save(two);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // no change
 
-    EcPerson three = Ebean.find(EcPerson.class)
+    EcPerson three = DB.find(EcPerson.class)
       .setId(person.getId())
       .findOne();
 
     assertThat(three.getName()).isEqualTo("CacheMod");
     assertThat(three.getPhoneNumbers()).contains("021 1234", "021 4321", "027 234234");
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // cache hit
 
     three.getPhoneNumbers().add("09 6534");
-    Ebean.save(three);
+    DB.save(three);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7); // cache hit
     } else {
       assertThat(sql).hasSize(5); // cache hit
     }
 
-    EcPerson four = Ebean.find(EcPerson.class)
+    EcPerson four = DB.find(EcPerson.class)
       .setId(person.getId())
       .fetch("phoneNumbers")
       .findOne();
@@ -82,15 +82,16 @@ public class TestElementCollectionBasicCache extends BaseTestCase {
     assertThat(four.getName()).isEqualTo("CacheMod");
     assertThat(four.getPhoneNumbers()).contains("021 1234", "021 4321", "027 234234", "09 6534");
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // cache hit
 
-    Ebean.delete(four);
+    DB.delete(four);
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 
+  @Override
   public boolean isPersistBatchOnCascade() {
-    return ((SpiEbeanServer) Ebean.getDefaultServer()).getDatabasePlatform().getPersistBatchOnCascade() != PersistBatch.NONE;
+    return ((SpiEbeanServer) DB.getDefault()).databasePlatform().getPersistBatchOnCascade() != PersistBatch.NONE;
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMap.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMap.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMap.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMap.java
index 277e7bb37..366ad5570 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMap.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMap.java
@@ -2,8 +2,8 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.HashMap;
 import java.util.List;
@@ -16,14 +16,14 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
   @Test
   public void test() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     EcmPerson person = new EcmPerson("MFiona021");
     person.getPhoneNumbers().put("home", "021 1234");
     person.getPhoneNumbers().put("work", "021 4321");
     DB.save(person);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(4);
       assertSql(sql.get(0)).contains("insert into ecm_person");
@@ -42,7 +42,7 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
     person1.getPhoneNumbers().put("mob", "09 9876");
     DB.save(person1);
 
-    LoggedSqlCollector.current();
+    LoggedSql.collect();
 
     List<EcmPerson> found =
       DB.find(EcmPerson.class).where()
@@ -61,7 +61,7 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
     assertThat(phoneNumbers1).containsValues("09 1234", "09 4321", "09 9876");
     assertThat(phoneNumbers1.get("mob")).isEqualTo("09 9876");
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t0.version from ecm_person t0 where");
     assertSql(sql.get(1)).contains("select t0.ecm_person_id, t0.type, t0.phnum from ecm_person_phone_numbers t0 where");
@@ -76,7 +76,7 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
 
     assertThat(found2).hasSize(2);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t0.version, t1.type, t1.phnum from ecm_person t0 left join ecm_person_phone_numbers t1");
 
@@ -84,7 +84,7 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
     jsonToFrom(foundFirst);
     updateBasic(foundFirst);
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 
   private void updateBasic(EcmPerson bean) {
@@ -92,7 +92,7 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
     bean.setName("Fiona021-mod-0");
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("update ecm_person");
 
@@ -105,7 +105,7 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
     bean.getPhoneNumbers().put("one", "01-22123");
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSql(sql.get(0)).contains("update ecm_person set name=?, version=? where id=? and version=?");
@@ -129,7 +129,7 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
 
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(0);
 
     updateOnlyCollection(bean);
@@ -140,7 +140,7 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
     bean.getPhoneNumbers().put("two", "01-4321");
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSql(sql.get(0)).contains("delete from ecm_person_phone_numbers where ecm_person_id=?");
@@ -163,7 +163,7 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
 
     DB.delete(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from ecm_person_phone_numbers where ecm_person_id = ?");
     assertSql(sql.get(1)).contains("delete from ecm_person where id=? and version=?");
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapAsLob.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapAsLob.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapAsLob.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapAsLob.java
index 0fc42ea26..af02d2a26 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapAsLob.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapAsLob.java
@@ -1,9 +1,9 @@
 package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -14,14 +14,14 @@ public class TestElementCollectionBasicMapAsLob extends BaseTestCase {
   @Test
   public void test() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     EcmcPerson person = new EcmcPerson("Lob021");
     person.getPhoneNumbers().put("home", "021 1234");
     person.getPhoneNumbers().put("work", "021 4321");
-    Ebean.save(person);
+    DB.save(person);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(4);
       assertSql(sql.get(0)).contains("insert into ecmc_person");
@@ -34,7 +34,7 @@ public class TestElementCollectionBasicMapAsLob extends BaseTestCase {
       assertSql(sql.get(2)).contains("insert into ecmc_person_phone");
     }
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapCache.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapCache.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapCache.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapCache.java
index 2da2d9d1f..fef7fb95e 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapCache.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapCache.java
@@ -1,11 +1,11 @@
 package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.PersistBatch;
+import io.ebean.test.LoggedSql;
 import io.ebeaninternal.api.SpiEbeanServer;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -19,31 +19,31 @@ public class TestElementCollectionBasicMapCache extends BaseTestCase {
     EcmPerson person = new EcmPerson("CacheMap");
     person.getPhoneNumbers().put("home", "021 1234");
     person.getPhoneNumbers().put("work", "021 4321");
-    Ebean.save(person);
+    DB.save(person);
 
 
-    EcmPerson one = Ebean.find(EcmPerson.class)
+    EcmPerson one = DB.find(EcmPerson.class)
       .setId(person.getId())
       .fetch("phoneNumbers")
       .findOne();
 
     one.getPhoneNumbers().size();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    EcmPerson two = Ebean.find(EcmPerson.class)
+    EcmPerson two = DB.find(EcmPerson.class)
       .setId(person.getId())
       .findOne();
 
     two.setName("CacheMod");
     two.getPhoneNumbers().put("mob", "027 234234");
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // cache hit containing phone numbers
 
-    Ebean.save(two);
+    DB.save(two);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSqlBind(sql, 4, 6);
@@ -51,27 +51,27 @@ public class TestElementCollectionBasicMapCache extends BaseTestCase {
       assertThat(sql).hasSize(5);
     }
 
-    Ebean.save(two);
+    DB.save(two);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // no change
 
-    EcmPerson three = Ebean.find(EcmPerson.class)
+    EcmPerson three = DB.find(EcmPerson.class)
       .setId(person.getId())
       .findOne();
 
     assertThat(three.getName()).isEqualTo("CacheMod");
     assertThat(three.getPhoneNumbers().toString()).contains("021 1234", "021 4321", "027 234234");
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // cache hit
 
     three.getPhoneNumbers().put("oth", "09 6534");
     three.getPhoneNumbers().remove("home");
     three.getPhoneNumbers().remove("work");
-    Ebean.save(three);
+    DB.save(three);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(5); // cache hit
       assertSqlBind(sql, 3, 4);
@@ -79,7 +79,7 @@ public class TestElementCollectionBasicMapCache extends BaseTestCase {
       assertThat(sql).hasSize(3); // cache hit
     }
 
-    EcmPerson four = Ebean.find(EcmPerson.class)
+    EcmPerson four = DB.find(EcmPerson.class)
       .setId(person.getId())
       .fetch("phoneNumbers")
       .findOne();
@@ -88,15 +88,16 @@ public class TestElementCollectionBasicMapCache extends BaseTestCase {
     assertThat(four.getPhoneNumbers().toString()).contains("027 234234", "09 6534");
     assertThat(four.getPhoneNumbers()).hasSize(2);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // cache hit
 
-    Ebean.delete(four);
+    DB.delete(four);
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 
+  @Override
   public boolean isPersistBatchOnCascade() {
-    return ((SpiEbeanServer) Ebean.getDefaultServer()).getDatabasePlatform().getPersistBatchOnCascade() != PersistBatch.NONE;
+    return ((SpiEbeanServer) DB.getDefault()).databasePlatform().getPersistBatchOnCascade() != PersistBatch.NONE;
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicSet.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicSet.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicSet.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicSet.java
index 02f6fa5d3..3f3f8342d 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicSet.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicSet.java
@@ -2,8 +2,8 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.Set;
@@ -15,14 +15,14 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
   @Test
   public void test() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     EcsPerson person = new EcsPerson("Fiona021");
     person.getPhoneNumbers().add("021 1234");
     person.getPhoneNumbers().add("021 4321");
     DB.save(person);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(4);
       assertSql(sql.get(0)).contains("insert into ecs_person");
@@ -41,7 +41,7 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
     person1.getPhoneNumbers().add("09 9876");
     DB.save(person1);
 
-    LoggedSqlCollector.current();
+    LoggedSql.collect();
 
     List<EcsPerson> found =
       DB.find(EcsPerson.class).where()
@@ -56,7 +56,7 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
     assertThat(phoneNumbers0).containsExactly("021 1234", "021 4321");
     assertThat(phoneNumbers1).containsExactly("09 1234", "09 4321", "09 9876");
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t0.version from ecs_person t0 where");
     assertSql(sql.get(1)).contains("select t0.ecs_person_id, t0.phone from ecs_person_phone t0 where");
@@ -71,7 +71,7 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
 
     assertThat(found2).hasSize(2);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t0.version, t1.phone from ecs_person t0 left join ecs_person_phone t1");
 
@@ -80,7 +80,7 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
 
     updateBasic(foundFirst);
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 
   private void updateBasic(EcsPerson bean) {
@@ -88,7 +88,7 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
     bean.setName("Fiona021-mod-0");
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("update ecs_person");
 
@@ -101,7 +101,7 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
     bean.getPhoneNumbers().add("01-22123");
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSql(sql.get(0)).contains("update ecs_person set name=?, version=? where id=? and version=?");
@@ -125,7 +125,7 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
 
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(0);
 
     updateOnlyCollection(bean);
@@ -136,7 +136,7 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
     bean.getPhoneNumbers().add("01-4321");
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSql(sql.get(0)).contains("delete from ecs_person_phone where ecs_person_id=?");
@@ -159,7 +159,7 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
 
     DB.delete(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from ecs_person_phone where ecs_person_id = ?");
     assertSql(sql.get(1)).contains("delete from ecs_person where id=? and version=?");
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascade.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascade.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascade.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascade.java
index 4518420f6..7d949d94a 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascade.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascade.java
@@ -2,7 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.LinkedHashMap;
 import java.util.List;
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascadeMultiple.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascadeMultiple.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascadeMultiple.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascadeMultiple.java
index e7291ba33..0278dd465 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascadeMultiple.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionCascadeMultiple.java
@@ -3,8 +3,8 @@ package org.tests.model.elementcollection;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.annotation.Transactional;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -24,11 +24,11 @@ public class TestElementCollectionCascadeMultiple extends BaseTestCase {
     top.setPerson(person);
     top.getPeople().add(person);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     save(top);
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(9);
 
     assertSql(sql.get(0)).contains("insert into ecs_person");
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedList.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedList.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedList.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedList.java
index 47e47727b..1c19069c6 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedList.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedList.java
@@ -2,8 +2,8 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -14,14 +14,14 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
   @Test
   public void test() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     EcblPerson person = new EcblPerson("Fiona64021");
     person.getPhoneNumbers().add(new EcPhone("64", "021", "1234"));
     person.getPhoneNumbers().add(new EcPhone("64", "021", "4321"));
     DB.save(person);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(4);
       assertSql(sql.get(0)).contains("insert into ecbl_person");
@@ -39,7 +39,7 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
     person1.getPhoneNumbers().add(new EcPhone("64", "09", "4321"));
     DB.save(person1);
 
-    LoggedSqlCollector.current();
+    LoggedSql.collect();
 
     List<EcblPerson> found =
       DB.find(EcblPerson.class).where()
@@ -54,7 +54,7 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
     assertThat(phoneNumbers0.toString()).contains("64-021-1234", "64-021-4321");
     assertThat(phoneNumbers1.toString()).contains("61-09-1234", "64-09-4321");
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.id, t0.name, t0.version from ecbl_person");
     assertSql(sql.get(1)).contains("select t0.person_id, t0.country_code, t0.area, t0.phnum from ecbl_person_phone_numbers");
@@ -69,7 +69,7 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
 
     assertThat(found2).hasSize(2);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     String trimmedSql = trimSql(sql.get(0));
     assertThat(trimmedSql).contains("select t0.id, t0.name, t0.version, t1.country_code, t1.area, t1.phnum from ecbl_person t0 left join ecbl_person_phone_numbers t1");
@@ -80,7 +80,7 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
 
     updateBasic(foundFirst);
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 
   private void updateBasic(EcblPerson bean) {
@@ -88,7 +88,7 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
     bean.setName("Fiona64-mod-0");
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("update ecbl_person");
 
@@ -101,7 +101,7 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
     bean.getPhoneNumbers().add(new EcPhone("01", "234", "123"));
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSql(sql.get(0)).contains("update ecbl_person set name=?, version=? where id=? and version=?");
@@ -125,7 +125,7 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
 
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(0);
 
     updateOnlyCollection(bean);
@@ -136,7 +136,7 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
     bean.getPhoneNumbers().add(new EcPhone("01", "12", "4321"));
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSql(sql.get(0)).contains("delete from ecbl_person_phone_numbers where person_id=?");
@@ -159,7 +159,7 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
 
     DB.delete(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from ecbl_person_phone_numbers where person_id = ?");
     assertSql(sql.get(1)).contains("delete from ecbl_person where id=? and version=?");
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedListCache.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedListCache.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedListCache.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedListCache.java
index 56c22aa4c..f3ec4b24b 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedListCache.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedListCache.java
@@ -1,9 +1,9 @@
 package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -17,36 +17,36 @@ public class TestElementCollectionEmbeddedListCache extends BaseTestCase {
     EcblPerson person = new EcblPerson("CacheL");
     person.getPhoneNumbers().add(new EcPhone("64", "021","1234"));
     person.getPhoneNumbers().add(new EcPhone("64","021","4321"));
-    Ebean.save(person);
+    DB.save(person);
 
-    EcblPerson one = Ebean.find(EcblPerson.class)
+    EcblPerson one = DB.find(EcblPerson.class)
       .setId(person.getId())
       .fetch("phoneNumbers")
       .findOne();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     one.getPhoneNumbers().size();
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).isEmpty();
 
-    EcblPerson two = Ebean.find(EcblPerson.class)
+    EcblPerson two = DB.find(EcblPerson.class)
       .setId(person.getId())
       .findOne();
 
     two.getPhoneNumbers().size();
     assertThat(two.getPhoneNumbers().toString()).contains("64-021-1234", "64-021-4321");
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // cache hit
 
     two.getPhoneNumbers().add(new EcPhone("61", "07", "11"));
     two.getPhoneNumbers().remove(1);
 
-    Ebean.save(two);
+    DB.save(two);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(5); // update of collection only
       assertSql(sql.get(0)).contains("delete from ecbl_person_phone_numbers where person_id=?");
@@ -60,26 +60,26 @@ public class TestElementCollectionEmbeddedListCache extends BaseTestCase {
       assertSql(sql.get(2)).contains("insert into ecbl_person_phone_numbers (person_id,country_code,area,phnum) values (?,?,?,?)");
     }
 
-    EcblPerson three = Ebean.find(EcblPerson.class)
+    EcblPerson three = DB.find(EcblPerson.class)
       .setId(person.getId())
       .findOne();
 
     assertThat(three.getPhoneNumbers().toString()).contains("61-07-11", "64-021-1234");
     assertThat(three.getPhoneNumbers()).hasSize(2);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // cache hit
 
 
     three.setName("mod-3");
     three.getPhoneNumbers().remove(0);
 
-    Ebean.save(three);
+    DB.save(three);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(5);
 
-    EcblPerson four = Ebean.find(EcblPerson.class)
+    EcblPerson four = DB.find(EcblPerson.class)
       .setId(person.getId())
       .findOne();
 
@@ -87,11 +87,11 @@ public class TestElementCollectionEmbeddedListCache extends BaseTestCase {
     assertThat(four.getPhoneNumbers()).hasSize(1);
 
 
-    Ebean.delete(four);
-    sql = LoggedSqlCollector.current();
+    DB.delete(four);
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
 
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMap.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMap.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMap.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMap.java
index a214b225c..18912a254 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMap.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMap.java
@@ -2,8 +2,8 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.Map;
@@ -15,14 +15,14 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
   @Test
   public void test() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     EcbmPerson person = new EcbmPerson("Fiona64021");
     person.getPhoneNumbers().put("home", new EcPhone("64", "021","1234"));
     person.getPhoneNumbers().put("work", new EcPhone("64","021","4321"));
     DB.save(person);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(4);
       assertSql(sql.get(0)).contains("insert into ecbm_person");
@@ -41,7 +41,7 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
 
     DB.save(person1);
 
-    LoggedSqlCollector.current();
+    LoggedSql.collect();
 
     List<EcbmPerson> found =
       DB.find(EcbmPerson.class).where()
@@ -67,13 +67,13 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
     assertThat(found2).hasSize(2);
     EcbmPerson foundFirst = found2.get(0);
 
-    LoggedSqlCollector.current();
+    LoggedSql.collect();
 
     jsonToFrom(foundFirst);
 
     updateBasic(foundFirst);
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 
   private void updateBasic(EcbmPerson bean) {
@@ -81,7 +81,7 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
     bean.setName("Fiona64-mod-0");
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("update ecbm_person");
 
@@ -94,7 +94,7 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
     bean.getPhoneNumbers().put("more", new EcPhone("01", "234", "123"));
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSql(sql.get(0)).contains("update ecbm_person set name=?, version=? where id=? and version=?");
@@ -117,7 +117,7 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
 
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(0);
 
     updateOnlyCollection(bean);
@@ -128,7 +128,7 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
     bean.getPhoneNumbers().put("other", new EcPhone("01", "12", "4321"));
     DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(7);
       assertSql(sql.get(0)).contains("delete from ecbm_person_phone_numbers where person_id=?");
@@ -151,7 +151,7 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
 
     DB.delete(bean);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from ecbm_person_phone_numbers where person_id = ?");
     assertSql(sql.get(1)).contains("delete from ecbm_person where id=? and version=?");
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMapCache.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMapCache.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMapCache.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMapCache.java
index 94d970101..3c1802e78 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMapCache.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMapCache.java
@@ -1,9 +1,9 @@
 package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -17,37 +17,37 @@ public class TestElementCollectionEmbeddedMapCache extends BaseTestCase {
     EcbmPerson person = new EcbmPerson("Cache1");
     person.getPhoneNumbers().put("home", new EcPhone("64", "021", "1234"));
     person.getPhoneNumbers().put("work", new EcPhone("64", "021", "4321"));
-    Ebean.save(person);
+    DB.save(person);
 
 
-    EcbmPerson one = Ebean.find(EcbmPerson.class)
+    EcbmPerson one = DB.find(EcbmPerson.class)
       .setId(person.getId())
       .fetch("phoneNumbers")
       .findOne();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     one.getPhoneNumbers().size();
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).isEmpty();
 
-    EcbmPerson two = Ebean.find(EcbmPerson.class)
+    EcbmPerson two = DB.find(EcbmPerson.class)
       .setId(person.getId())
       .findOne();
 
     two.getPhoneNumbers().size();
     assertThat(two.getPhoneNumbers().toString()).contains("64-021-1234", "64-021-4321");
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // cache hit
 
     two.getPhoneNumbers().put("mob", new EcPhone("61", "07", "11"));
     two.getPhoneNumbers().remove("home");
 
-    Ebean.save(two);
+    DB.save(two);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(5); // update of collection only
       assertSql(sql.get(0)).contains("delete from ecbm_person_phone_numbers where person_id=?");
@@ -62,26 +62,26 @@ public class TestElementCollectionEmbeddedMapCache extends BaseTestCase {
       assertThat(sql.get(3)).contains("insert into ecbm_person_phone_numbers (person_id,mkey,country_code,area,phnum) values (?,?,?,?,?)");
     }
 
-    EcbmPerson three = Ebean.find(EcbmPerson.class)
+    EcbmPerson three = DB.find(EcbmPerson.class)
       .setId(person.getId())
       .findOne();
 
     assertThat(three.getPhoneNumbers().toString()).contains("61-07-11", "64-021-4321");
     assertThat(three.getPhoneNumbers()).hasSize(2);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).isEmpty(); // cache hit
 
 
     three.setName("mod-3");
     three.getPhoneNumbers().remove("work");
 
-    Ebean.save(three);
+    DB.save(three);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(5);
 
-    EcbmPerson four = Ebean.find(EcbmPerson.class)
+    EcbmPerson four = DB.find(EcbmPerson.class)
       .setId(person.getId())
       .findOne();
 
@@ -89,11 +89,11 @@ public class TestElementCollectionEmbeddedMapCache extends BaseTestCase {
     assertThat(four.getPhoneNumbers()).hasSize(1);
 
 
-    Ebean.delete(four);
-    sql = LoggedSqlCollector.current();
+    DB.delete(four);
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(2);
 
 
-    LoggedSqlCollector.stop();
+    LoggedSql.stop();
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEnumSet.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEnumSet.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEnumSet.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEnumSet.java
index 2a26c5ea0..e60921867 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionEnumSet.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionEnumSet.java
@@ -2,7 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionResused.java b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionResused.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionResused.java
rename to ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionResused.java
index d95b2549e..2c55ceae4 100644
--- a/ebean-core/src/test/java/org/tests/model/elementcollection/TestElementCollectionResused.java
+++ b/ebean-test/src/test/java/org/tests/model/elementcollection/TestElementCollectionResused.java
@@ -2,7 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EAddr.java b/ebean-test/src/test/java/org/tests/model/embedded/EAddr.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/embedded/EAddr.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EAddr.java
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EAddress.java b/ebean-test/src/test/java/org/tests/model/embedded/EAddress.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/embedded/EAddress.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EAddress.java
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EAddressStatus.java b/ebean-test/src/test/java/org/tests/model/embedded/EAddressStatus.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/embedded/EAddressStatus.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EAddressStatus.java
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EEmbDatePeriod.java b/ebean-test/src/test/java/org/tests/model/embedded/EEmbDatePeriod.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/embedded/EEmbDatePeriod.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EEmbDatePeriod.java
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EEmbInner.java b/ebean-test/src/test/java/org/tests/model/embedded/EEmbInner.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/embedded/EEmbInner.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EEmbInner.java
index f08c5a35b..c42510d67 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/EEmbInner.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/EEmbInner.java
@@ -1,10 +1,6 @@
 package org.tests.model.embedded;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "eemb_inner")
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EEmbOuter.java b/ebean-test/src/test/java/org/tests/model/embedded/EEmbOuter.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/embedded/EEmbOuter.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EEmbOuter.java
index 1ae4da057..2f6797c33 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/EEmbOuter.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/EEmbOuter.java
@@ -1,12 +1,6 @@
 package org.tests.model.embedded;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Embedded;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EInvoice.java b/ebean-test/src/test/java/org/tests/model/embedded/EInvoice.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/embedded/EInvoice.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EInvoice.java
index 0b833fdd1..98e3a1733 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/EInvoice.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/EInvoice.java
@@ -2,11 +2,7 @@ package org.tests.model.embedded;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.Embedded;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.Date;
 
 @Cache
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EMain.java b/ebean-test/src/test/java/org/tests/model/embedded/EMain.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/embedded/EMain.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EMain.java
index 2b5776999..edb13ac1b 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/EMain.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/EMain.java
@@ -1,10 +1,6 @@
 package org.tests.model.embedded;
 
-import javax.persistence.Embedded;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "e_main")
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EPerAddr.java b/ebean-test/src/test/java/org/tests/model/embedded/EPerAddr.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/embedded/EPerAddr.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EPerAddr.java
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EPerson.java b/ebean-test/src/test/java/org/tests/model/embedded/EPerson.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/embedded/EPerson.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EPerson.java
index 8a0c60446..ef5e82a80 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/EPerson.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/EPerson.java
@@ -1,12 +1,6 @@
 package org.tests.model.embedded;
 
-import javax.persistence.AttributeOverride;
-import javax.persistence.AttributeOverrides;
-import javax.persistence.Column;
-import javax.persistence.Embedded;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class EPerson {
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EPerson2.java b/ebean-test/src/test/java/org/tests/model/embedded/EPerson2.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/embedded/EPerson2.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EPerson2.java
index e4c11d935..b532ceff6 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/EPerson2.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/EPerson2.java
@@ -1,12 +1,6 @@
 package org.tests.model.embedded;
 
-import javax.persistence.AttributeOverride;
-import javax.persistence.AttributeOverrides;
-import javax.persistence.Column;
-import javax.persistence.Embedded;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class EPerson2 {
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/EPerson3.java b/ebean-test/src/test/java/org/tests/model/embedded/EPerson3.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/model/embedded/EPerson3.java
rename to ebean-test/src/test/java/org/tests/model/embedded/EPerson3.java
index 78c87ab9b..59e793384 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/EPerson3.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/EPerson3.java
@@ -1,12 +1,6 @@
 package org.tests.model.embedded;
 
-import javax.persistence.AttributeOverride;
-import javax.persistence.AttributeOverrides;
-import javax.persistence.Column;
-import javax.persistence.Embedded;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class EPerson3 {
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/Eembeddable.java b/ebean-test/src/test/java/org/tests/model/embedded/Eembeddable.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/embedded/Eembeddable.java
rename to ebean-test/src/test/java/org/tests/model/embedded/Eembeddable.java
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/PrimaryRevision.java b/ebean-test/src/test/java/org/tests/model/embedded/PrimaryRevision.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/embedded/PrimaryRevision.java
rename to ebean-test/src/test/java/org/tests/model/embedded/PrimaryRevision.java
index ac5f5d6b3..912e95e87 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/PrimaryRevision.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/PrimaryRevision.java
@@ -1,10 +1,6 @@
 package org.tests.model.embedded;
 
-import javax.persistence.AttributeOverride;
-import javax.persistence.Column;
-import javax.persistence.EmbeddedId;
-import javax.persistence.Entity;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class PrimaryRevision {
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/RevisionId.java b/ebean-test/src/test/java/org/tests/model/embedded/RevisionId.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/embedded/RevisionId.java
rename to ebean-test/src/test/java/org/tests/model/embedded/RevisionId.java
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedAttrOverride.java b/ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedAttrOverride.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedAttrOverride.java
rename to ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedAttrOverride.java
index 264bef274..fe1c32cb4 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedAttrOverride.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedAttrOverride.java
@@ -1,9 +1,9 @@
 package org.tests.model.embedded;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -17,10 +17,10 @@ public class TestEmbeddedAttrOverride extends BaseTestCase {
     PrimaryRevision bean = new PrimaryRevision(100);
     bean.setName("hello");
 
-    LoggedSqlCollector.start();
-    Ebean.save(bean);
+    LoggedSql.start();
+    DB.save(bean);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("insert into primary_revision (id, revision, name, version) values (?,?,?,?)");
   }
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedEqualsWhenCreated.java b/ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedEqualsWhenCreated.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedEqualsWhenCreated.java
rename to ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedEqualsWhenCreated.java
index f5dcb38b9..77fca97ee 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedEqualsWhenCreated.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedEqualsWhenCreated.java
@@ -1,9 +1,9 @@
 package org.tests.model.embedded;
 
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestEmbeddedEqualsWhenCreated {
 
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedManyToOne.java b/ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedManyToOne.java
similarity index 64%
rename from ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedManyToOne.java
rename to ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedManyToOne.java
index fe957ef88..02859e645 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedManyToOne.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedManyToOne.java
@@ -1,11 +1,11 @@
 package org.tests.model.embedded;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.plugin.BeanType;
 import io.ebean.plugin.Property;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.ResetBasicData;
 
@@ -20,32 +20,32 @@ public class TestEmbeddedManyToOne extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    BeanType<EAddr> embType = Ebean.getDefaultServer().getPluginApi().getBeanType(EAddr.class);
+    BeanType<EAddr> embType = DB.getDefault().pluginApi().beanType(EAddr.class);
 
-    Ebean.getDefaultServer().getServerCacheManager().clearAll();
+    DB.getDefault().cacheManager().clearAll();
 
-    Country nz = Ebean.getReference(Country.class, "NZ");
+    Country nz = DB.reference(Country.class, "NZ");
 
     EAddr addr = new EAddr("Foo", "Bar", nz);
     EPerAddr perAddr = new EPerAddr("Embed", addr);
 
-    Property country = embType.getProperty("country");
-    Object val = country.getVal(addr);
+    Property country = embType.property("country");
+    Object val = country.value(addr);
 
     assertThat(val).isSameAs(nz);
 
-    Ebean.save(perAddr);
+    DB.save(perAddr);
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    EPerAddr found = Ebean.find(EPerAddr.class, perAddr.getId());
+    EPerAddr found = DB.find(EPerAddr.class, perAddr.getId());
 
     assertThat(found.getAddress().getCountry().getCode()).isEqualTo("NZ");
     assertThat(found.getAddress().getCountry().getName()).startsWith("New");
 
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
 
     if (isH2()) {
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedNullableOverride.java b/ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedNullableOverride.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedNullableOverride.java
rename to ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedNullableOverride.java
index 2b19bc612..f6f636c1e 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/TestEmbeddedNullableOverride.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/TestEmbeddedNullableOverride.java
@@ -2,10 +2,10 @@ package org.tests.model.embedded;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestEmbeddedNullableOverride extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/UserInterestLive.java b/ebean-test/src/test/java/org/tests/model/embedded/UserInterestLive.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/embedded/UserInterestLive.java
rename to ebean-test/src/test/java/org/tests/model/embedded/UserInterestLive.java
index 286ef97fb..341f0670e 100644
--- a/ebean-core/src/test/java/org/tests/model/embedded/UserInterestLive.java
+++ b/ebean-test/src/test/java/org/tests/model/embedded/UserInterestLive.java
@@ -1,7 +1,7 @@
 package org.tests.model.embedded;
 
 import io.ebean.Model;
-import io.ebean.annotation.CreatedTimestamp;
+import io.ebean.annotation.WhenCreated;
 
 import javax.persistence.EmbeddedId;
 import javax.persistence.Entity;
@@ -13,7 +13,7 @@ public class UserInterestLive extends Model {
   @EmbeddedId
   private final UserInterestLiveKey key;
 
-  @CreatedTimestamp
+  @WhenCreated
   private Date createdAt;
 
   public UserInterestLive(UserInterestLiveKey key) {
diff --git a/ebean-core/src/test/java/org/tests/model/embedded/UserInterestLiveKey.java b/ebean-test/src/test/java/org/tests/model/embedded/UserInterestLiveKey.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/embedded/UserInterestLiveKey.java
rename to ebean-test/src/test/java/org/tests/model/embedded/UserInterestLiveKey.java
diff --git a/ebean-core/src/test/java/org/tests/model/family/ChildPerson.java b/ebean-test/src/test/java/org/tests/model/family/ChildPerson.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/family/ChildPerson.java
rename to ebean-test/src/test/java/org/tests/model/family/ChildPerson.java
diff --git a/ebean-core/src/test/java/org/tests/model/family/GrandParentPerson.java b/ebean-test/src/test/java/org/tests/model/family/GrandParentPerson.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/model/family/GrandParentPerson.java
rename to ebean-test/src/test/java/org/tests/model/family/GrandParentPerson.java
index 9ea2c97a2..621d81885 100644
--- a/ebean-core/src/test/java/org/tests/model/family/GrandParentPerson.java
+++ b/ebean-test/src/test/java/org/tests/model/family/GrandParentPerson.java
@@ -3,19 +3,14 @@ package org.tests.model.family;
 import io.ebean.annotation.Formula;
 import org.tests.model.basic.EBasic;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderBy;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
 @Entity
 public class GrandParentPerson extends InheritablePerson {
   private static final long serialVersionUID = 1L;
-  
+
   @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL)
   @OrderBy("identifier")
   private List<ParentPerson> children = new ArrayList<>();
@@ -41,8 +36,8 @@ public class GrandParentPerson extends InheritablePerson {
   @ManyToOne(optional = true, fetch = FetchType.EAGER)
   @Formula(select = "f3.id", join = "left join e_basic f3 on f3.name = ${ta}.family_name")
   private EBasic basicSameName;
-  
-  
+
+
   // Demonstrate formula usage
   @Formula(select = "coalesce(${ta}.some_bean_id,1)")
   @ManyToOne
@@ -84,11 +79,11 @@ public class GrandParentPerson extends InheritablePerson {
   public EBasic getEffectiveBean() {
     return effectiveBean;
   }
-  
+
   public EBasic getBasicSameName() {
     return basicSameName;
   }
-  
+
   public void setBasicSameName(EBasic basicSameName) {
     this.basicSameName = basicSameName;
   }
diff --git a/ebean-core/src/test/java/org/tests/model/family/InheritablePerson.java b/ebean-test/src/test/java/org/tests/model/family/InheritablePerson.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/family/InheritablePerson.java
rename to ebean-test/src/test/java/org/tests/model/family/InheritablePerson.java
index 36c7fc74f..113e95bc0 100644
--- a/ebean-core/src/test/java/org/tests/model/family/InheritablePerson.java
+++ b/ebean-test/src/test/java/org/tests/model/family/InheritablePerson.java
@@ -2,11 +2,10 @@ package org.tests.model.family;
 
 import org.tests.model.basic.EBasic;
 
-import java.io.Serializable;
-
 import javax.persistence.Id;
 import javax.persistence.ManyToOne;
 import javax.persistence.MappedSuperclass;
+import java.io.Serializable;
 
 @MappedSuperclass
 public abstract class InheritablePerson implements Serializable {
diff --git a/ebean-core/src/test/java/org/tests/model/family/ParentPerson.java b/ebean-test/src/test/java/org/tests/model/family/ParentPerson.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/model/family/ParentPerson.java
rename to ebean-test/src/test/java/org/tests/model/family/ParentPerson.java
index 242721993..4f48c9d33 100644
--- a/ebean-core/src/test/java/org/tests/model/family/ParentPerson.java
+++ b/ebean-test/src/test/java/org/tests/model/family/ParentPerson.java
@@ -3,11 +3,7 @@ package org.tests.model.family;
 import io.ebean.annotation.Formula;
 import org.tests.model.basic.EBasic;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderBy;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/generated/User.java b/ebean-test/src/test/java/org/tests/model/generated/User.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/generated/User.java
rename to ebean-test/src/test/java/org/tests/model/generated/User.java
diff --git a/ebean-core/src/test/java/org/tests/model/generated/WhoPropsOneToMany.java b/ebean-test/src/test/java/org/tests/model/generated/WhoPropsOneToMany.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/generated/WhoPropsOneToMany.java
rename to ebean-test/src/test/java/org/tests/model/generated/WhoPropsOneToMany.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HEmbiBean.java b/ebean-test/src/test/java/org/tests/model/history/HEmbiBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HEmbiBean.java
rename to ebean-test/src/test/java/org/tests/model/history/HEmbiBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HEmbiId.java b/ebean-test/src/test/java/org/tests/model/history/HEmbiId.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HEmbiId.java
rename to ebean-test/src/test/java/org/tests/model/history/HEmbiId.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HeDoc.java b/ebean-test/src/test/java/org/tests/model/history/HeDoc.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HeDoc.java
rename to ebean-test/src/test/java/org/tests/model/history/HeDoc.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HeLink.java b/ebean-test/src/test/java/org/tests/model/history/HeLink.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HeLink.java
rename to ebean-test/src/test/java/org/tests/model/history/HeLink.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HiDoc.java b/ebean-test/src/test/java/org/tests/model/history/HiDoc.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HiDoc.java
rename to ebean-test/src/test/java/org/tests/model/history/HiDoc.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HiLink.java b/ebean-test/src/test/java/org/tests/model/history/HiLink.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HiLink.java
rename to ebean-test/src/test/java/org/tests/model/history/HiLink.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HiTOne.java b/ebean-test/src/test/java/org/tests/model/history/HiTOne.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HiTOne.java
rename to ebean-test/src/test/java/org/tests/model/history/HiTOne.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HiTThree.java b/ebean-test/src/test/java/org/tests/model/history/HiTThree.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HiTThree.java
rename to ebean-test/src/test/java/org/tests/model/history/HiTThree.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HiTTwo.java b/ebean-test/src/test/java/org/tests/model/history/HiTTwo.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HiTTwo.java
rename to ebean-test/src/test/java/org/tests/model/history/HiTTwo.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HsdSetting.java b/ebean-test/src/test/java/org/tests/model/history/HsdSetting.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HsdSetting.java
rename to ebean-test/src/test/java/org/tests/model/history/HsdSetting.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/HsdUser.java b/ebean-test/src/test/java/org/tests/model/history/HsdUser.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/history/HsdUser.java
rename to ebean-test/src/test/java/org/tests/model/history/HsdUser.java
diff --git a/ebean-core/src/test/java/org/tests/model/history/TestHistoryEmbeddedId.java b/ebean-test/src/test/java/org/tests/model/history/TestHistoryEmbeddedId.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/history/TestHistoryEmbeddedId.java
rename to ebean-test/src/test/java/org/tests/model/history/TestHistoryEmbeddedId.java
index ffe82ac75..e76cd7714 100644
--- a/ebean-core/src/test/java/org/tests/model/history/TestHistoryEmbeddedId.java
+++ b/ebean-test/src/test/java/org/tests/model/history/TestHistoryEmbeddedId.java
@@ -6,14 +6,14 @@ import io.ebean.ValuePair;
 import io.ebean.Version;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestHistoryEmbeddedId extends BaseTestCase {
 
@@ -33,13 +33,13 @@ public class TestHistoryEmbeddedId extends BaseTestCase {
     assertNotNull(found);
     assertThat(found.getName()).isEqualTo("notTen");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     final List<Version<HEmbiBean>> versions =
       DB.find(HEmbiBean.class)
       .setId(id)
       .findVersions();
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(versions).hasSize(2);
 
     final Map<String, ValuePair> diff = versions.get(0).getDiff();
diff --git a/ebean-core/src/test/java/org/tests/model/history/TestHistoryExclude.java b/ebean-test/src/test/java/org/tests/model/history/TestHistoryExclude.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/history/TestHistoryExclude.java
rename to ebean-test/src/test/java/org/tests/model/history/TestHistoryExclude.java
index 0132f9d7f..b7b1e2f5b 100644
--- a/ebean-core/src/test/java/org/tests/model/history/TestHistoryExclude.java
+++ b/ebean-test/src/test/java/org/tests/model/history/TestHistoryExclude.java
@@ -1,10 +1,10 @@
 package org.tests.model.history;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 import java.util.List;
@@ -33,11 +33,11 @@ public class TestHistoryExclude extends BaseTestCase {
   public void testSoftDelete_includeSoftDeletes_findList() {
 
     HeLink l = new HeLink("two", "boo");
-    Ebean.save(l);
+    DB.save(l);
 
-    Ebean.delete(l);
+    DB.delete(l);
 
-    List<HeLink> list = Ebean.find(HeLink.class)
+    List<HeLink> list = DB.find(HeLink.class)
       .setIncludeSoftDeletes()
       .findList();
 
@@ -48,11 +48,11 @@ public class TestHistoryExclude extends BaseTestCase {
   public void testSoftDelete_includeSoftDeletes_findOne() {
 
     HeLink l = new HeLink("three", "boo2");
-    Ebean.save(l);
+    DB.save(l);
 
-    Ebean.delete(l);
+    DB.delete(l);
 
-    HeLink found = Ebean.find(HeLink.class)
+    HeLink found = DB.find(HeLink.class)
       .setId(l.getId())
       .setIncludeSoftDeletes()
       .findOne();
@@ -66,7 +66,7 @@ public class TestHistoryExclude extends BaseTestCase {
 
     prepare();
 
-    HeLink linkFound = Ebean.find(HeLink.class, link.getId());
+    HeLink linkFound = DB.find(HeLink.class, link.getId());
     linkFound.getDocs().size();
   }
 
@@ -76,7 +76,7 @@ public class TestHistoryExclude extends BaseTestCase {
 
     prepare();
 
-    HeLink linkFound = Ebean.find(HeLink.class)
+    HeLink linkFound = DB.find(HeLink.class)
       .asOf(new Timestamp(System.currentTimeMillis() + DB_CLOCK_DELTA))
       .setId(link.getId())
       .findOne();
diff --git a/ebean-core/src/test/java/org/tests/model/history/TestHistoryInclude.java b/ebean-test/src/test/java/org/tests/model/history/TestHistoryInclude.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/history/TestHistoryInclude.java
rename to ebean-test/src/test/java/org/tests/model/history/TestHistoryInclude.java
index 1ba178b70..3c462c1cc 100644
--- a/ebean-core/src/test/java/org/tests/model/history/TestHistoryInclude.java
+++ b/ebean-test/src/test/java/org/tests/model/history/TestHistoryInclude.java
@@ -1,10 +1,10 @@
 package org.tests.model.history;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 
@@ -33,7 +33,7 @@ public class TestHistoryInclude extends BaseTestCase {
 
     prepare();
 
-    HiLink linkFound = Ebean.find(HiLink.class, link.getId());
+    HiLink linkFound = DB.find(HiLink.class, link.getId());
     assertThat(linkFound.getDocs().size()).isEqualTo(2);
   }
 
@@ -43,7 +43,7 @@ public class TestHistoryInclude extends BaseTestCase {
 
     prepare();
 
-    HiLink linkFound = Ebean.find(HiLink.class)
+    HiLink linkFound = DB.find(HiLink.class)
       .asOf(new Timestamp(System.currentTimeMillis() + DB_CLOCK_DELTA))
       .setId(link.getId())
       .findOne();
diff --git a/ebean-core/src/test/java/org/tests/model/history/TestHistoryOneToMany.java b/ebean-test/src/test/java/org/tests/model/history/TestHistoryOneToMany.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/model/history/TestHistoryOneToMany.java
rename to ebean-test/src/test/java/org/tests/model/history/TestHistoryOneToMany.java
index 75e0bc871..42a214988 100644
--- a/ebean-core/src/test/java/org/tests/model/history/TestHistoryOneToMany.java
+++ b/ebean-test/src/test/java/org/tests/model/history/TestHistoryOneToMany.java
@@ -4,8 +4,8 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 import java.util.List;
@@ -40,7 +40,7 @@ public class TestHistoryOneToMany extends BaseTestCase {
     DB.save(one);
     Thread.sleep(20);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<HiTOne> list = DB.find(HiTOne.class)
       .fetch("twos")
@@ -50,7 +50,7 @@ public class TestHistoryOneToMany extends BaseTestCase {
       .asOf(new Timestamp(System.currentTimeMillis()))
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(list).hasSize(1);
     assertThat(list.get(0).getTwos()).hasSize(2);
diff --git a/ebean-core/src/test/java/org/tests/model/history/TestHistorySoftDeleteOneToOne.java b/ebean-test/src/test/java/org/tests/model/history/TestHistorySoftDeleteOneToOne.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/model/history/TestHistorySoftDeleteOneToOne.java
rename to ebean-test/src/test/java/org/tests/model/history/TestHistorySoftDeleteOneToOne.java
index 36ba5d279..6ac425f71 100644
--- a/ebean-core/src/test/java/org/tests/model/history/TestHistorySoftDeleteOneToOne.java
+++ b/ebean-test/src/test/java/org/tests/model/history/TestHistorySoftDeleteOneToOne.java
@@ -1,8 +1,8 @@
 package org.tests.model.history;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -13,10 +13,10 @@ public class TestHistorySoftDeleteOneToOne extends BaseTestCase {
 
     HsdUser u1 = new HsdUser("u1");
 
-    Ebean.save(u1);
-    Ebean.delete(u1);
+    DB.save(u1);
+    DB.delete(u1);
 
-    HsdUser one = Ebean.find(HsdUser.class)
+    HsdUser one = DB.find(HsdUser.class)
       .setId(u1.getId())
       .setIncludeSoftDeletes()
       .findOne();
diff --git a/ebean-core/src/test/java/org/tests/model/info/InfoCompany.java b/ebean-test/src/test/java/org/tests/model/info/InfoCompany.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/info/InfoCompany.java
rename to ebean-test/src/test/java/org/tests/model/info/InfoCompany.java
index c2f699723..ea2651039 100644
--- a/ebean-core/src/test/java/org/tests/model/info/InfoCompany.java
+++ b/ebean-test/src/test/java/org/tests/model/info/InfoCompany.java
@@ -4,11 +4,7 @@ import io.ebean.Finder;
 import io.ebean.Model;
 import io.ebean.annotation.JsonIgnore;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/info/InfoContact.java b/ebean-test/src/test/java/org/tests/model/info/InfoContact.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/info/InfoContact.java
rename to ebean-test/src/test/java/org/tests/model/info/InfoContact.java
diff --git a/ebean-core/src/test/java/org/tests/model/info/InfoCustomer.java b/ebean-test/src/test/java/org/tests/model/info/InfoCustomer.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/info/InfoCustomer.java
rename to ebean-test/src/test/java/org/tests/model/info/InfoCustomer.java
index 086475b59..bf93c9c58 100644
--- a/ebean-core/src/test/java/org/tests/model/info/InfoCustomer.java
+++ b/ebean-test/src/test/java/org/tests/model/info/InfoCustomer.java
@@ -3,11 +3,7 @@ package org.tests.model.info;
 import io.ebean.Finder;
 import io.ebean.Model;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class InfoCustomer extends Model {
diff --git a/ebean-core/src/test/java/org/tests/model/inheritexposedtype/IXPhoto.java b/ebean-test/src/test/java/org/tests/model/inheritexposedtype/IXPhoto.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/inheritexposedtype/IXPhoto.java
rename to ebean-test/src/test/java/org/tests/model/inheritexposedtype/IXPhoto.java
diff --git a/ebean-core/src/test/java/org/tests/model/inheritexposedtype/IXResource.java b/ebean-test/src/test/java/org/tests/model/inheritexposedtype/IXResource.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/model/inheritexposedtype/IXResource.java
rename to ebean-test/src/test/java/org/tests/model/inheritexposedtype/IXResource.java
index b7b93cd85..e2c052a49 100644
--- a/ebean-core/src/test/java/org/tests/model/inheritexposedtype/IXResource.java
+++ b/ebean-test/src/test/java/org/tests/model/inheritexposedtype/IXResource.java
@@ -1,10 +1,6 @@
 package org.tests.model.inheritexposedtype;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
+import javax.persistence.*;
 import java.util.UUID;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/inheritexposedtype/test/TestInheritExposeDtype.java b/ebean-test/src/test/java/org/tests/model/inheritexposedtype/test/TestInheritExposeDtype.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/model/inheritexposedtype/test/TestInheritExposeDtype.java
rename to ebean-test/src/test/java/org/tests/model/inheritexposedtype/test/TestInheritExposeDtype.java
index aea5586cf..395f99a13 100644
--- a/ebean-core/src/test/java/org/tests/model/inheritexposedtype/test/TestInheritExposeDtype.java
+++ b/ebean-test/src/test/java/org/tests/model/inheritexposedtype/test/TestInheritExposeDtype.java
@@ -1,9 +1,9 @@
 package org.tests.model.inheritexposedtype.test;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.inheritexposedtype.IXPhoto;
-import org.junit.Test;
 
 public class TestInheritExposeDtype extends BaseTestCase {
 
@@ -12,14 +12,14 @@ public class TestInheritExposeDtype extends BaseTestCase {
 
     IXPhoto p = new IXPhoto();
     p.setName("the name");
-    Ebean.save(p);
+    DB.save(p);
 
     // update
     p.setName("new name");
-    Ebean.save(p);
+    DB.save(p);
 
     // delete
-    Ebean.delete(p);
+    DB.delete(p);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/inheritmany/IMRelated.java b/ebean-test/src/test/java/org/tests/model/inheritmany/IMRelated.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/inheritmany/IMRelated.java
rename to ebean-test/src/test/java/org/tests/model/inheritmany/IMRelated.java
diff --git a/ebean-core/src/test/java/org/tests/model/inheritmany/IMRoot.java b/ebean-test/src/test/java/org/tests/model/inheritmany/IMRoot.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/model/inheritmany/IMRoot.java
rename to ebean-test/src/test/java/org/tests/model/inheritmany/IMRoot.java
index 553b12fad..f8d38fab5 100644
--- a/ebean-core/src/test/java/org/tests/model/inheritmany/IMRoot.java
+++ b/ebean-test/src/test/java/org/tests/model/inheritmany/IMRoot.java
@@ -1,10 +1,6 @@
 package org.tests.model.inheritmany;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.OneToMany;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/inheritmany/IMRootOne.java b/ebean-test/src/test/java/org/tests/model/inheritmany/IMRootOne.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/inheritmany/IMRootOne.java
rename to ebean-test/src/test/java/org/tests/model/inheritmany/IMRootOne.java
diff --git a/ebean-core/src/test/java/org/tests/model/inheritmany/IMRootTwo.java b/ebean-test/src/test/java/org/tests/model/inheritmany/IMRootTwo.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/inheritmany/IMRootTwo.java
rename to ebean-test/src/test/java/org/tests/model/inheritmany/IMRootTwo.java
diff --git a/ebean-core/src/test/java/org/tests/model/inheritmany/MBase.java b/ebean-test/src/test/java/org/tests/model/inheritmany/MBase.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/inheritmany/MBase.java
rename to ebean-test/src/test/java/org/tests/model/inheritmany/MBase.java
diff --git a/ebean-core/src/test/java/org/tests/model/inheritmany/MMedia.java b/ebean-test/src/test/java/org/tests/model/inheritmany/MMedia.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/model/inheritmany/MMedia.java
rename to ebean-test/src/test/java/org/tests/model/inheritmany/MMedia.java
index d59055c71..95e3b97e8 100644
--- a/ebean-core/src/test/java/org/tests/model/inheritmany/MMedia.java
+++ b/ebean-test/src/test/java/org/tests/model/inheritmany/MMedia.java
@@ -1,10 +1,6 @@
 package org.tests.model.inheritmany;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.Entity;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
+import javax.persistence.*;
 
 @Entity
 @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
diff --git a/ebean-core/src/test/java/org/tests/model/inheritmany/MPicture.java b/ebean-test/src/test/java/org/tests/model/inheritmany/MPicture.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/inheritmany/MPicture.java
rename to ebean-test/src/test/java/org/tests/model/inheritmany/MPicture.java
diff --git a/ebean-core/src/test/java/org/tests/model/inheritmany/MProfile.java b/ebean-test/src/test/java/org/tests/model/inheritmany/MProfile.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/inheritmany/MProfile.java
rename to ebean-test/src/test/java/org/tests/model/inheritmany/MProfile.java
diff --git a/ebean-core/src/test/java/org/tests/model/inheritmany/TestMediaInheritanceJoinToMany.java b/ebean-test/src/test/java/org/tests/model/inheritmany/TestMediaInheritanceJoinToMany.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/model/inheritmany/TestMediaInheritanceJoinToMany.java
rename to ebean-test/src/test/java/org/tests/model/inheritmany/TestMediaInheritanceJoinToMany.java
index baf913b7c..181d9af22 100644
--- a/ebean-core/src/test/java/org/tests/model/inheritmany/TestMediaInheritanceJoinToMany.java
+++ b/ebean-test/src/test/java/org/tests/model/inheritmany/TestMediaInheritanceJoinToMany.java
@@ -1,13 +1,14 @@
 package org.tests.model.inheritmany;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Random;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestMediaInheritanceJoinToMany extends BaseTestCase {
 
   @Test
@@ -18,13 +19,13 @@ public class TestMediaInheritanceJoinToMany extends BaseTestCase {
     MProfile profileWithNoPic = new MProfile();
     profileWithNoPic.setName(name);
 
-    Ebean.save(profileWithNoPic);
+    DB.save(profileWithNoPic);
 
-    Query<MProfile> query = Ebean.find(MProfile.class).fetch("picture").where().eq("name", name).query();
+    Query<MProfile> query = DB.find(MProfile.class).fetch("picture").where().eq("name", name).query();
 
     // assert we get the profile with a null picture
     MProfile profile = query.findOne();
-    Assert.assertNotNull(profile);
+    assertNotNull(profile);
 
     String generatedSql = query.getGeneratedSql();
     assertSql(generatedSql).contains("select t0.id, t0.name, t1.type, t1.id, t1.url, t1.note from mprofile t0 left join mmedia t1 on t1.id = t0.picture_id and t1.type = 'Picture' where t0.name = ?");
diff --git a/ebean-core/src/test/java/org/tests/model/interfaces/Address.java b/ebean-test/src/test/java/org/tests/model/interfaces/Address.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/interfaces/Address.java
rename to ebean-test/src/test/java/org/tests/model/interfaces/Address.java
diff --git a/ebean-core/src/test/java/org/tests/model/interfaces/IAddress.java b/ebean-test/src/test/java/org/tests/model/interfaces/IAddress.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/interfaces/IAddress.java
rename to ebean-test/src/test/java/org/tests/model/interfaces/IAddress.java
diff --git a/ebean-core/src/test/java/org/tests/model/interfaces/IPerson.java b/ebean-test/src/test/java/org/tests/model/interfaces/IPerson.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/interfaces/IPerson.java
rename to ebean-test/src/test/java/org/tests/model/interfaces/IPerson.java
diff --git a/ebean-core/src/test/java/org/tests/model/interfaces/IPersona.java b/ebean-test/src/test/java/org/tests/model/interfaces/IPersona.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/interfaces/IPersona.java
rename to ebean-test/src/test/java/org/tests/model/interfaces/IPersona.java
diff --git a/ebean-core/src/test/java/org/tests/model/interfaces/Person.java b/ebean-test/src/test/java/org/tests/model/interfaces/Person.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/interfaces/Person.java
rename to ebean-test/src/test/java/org/tests/model/interfaces/Person.java
diff --git a/ebean-core/src/test/java/org/tests/model/interfaces/Persona.java b/ebean-test/src/test/java/org/tests/model/interfaces/Persona.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/interfaces/Persona.java
rename to ebean-test/src/test/java/org/tests/model/interfaces/Persona.java
diff --git a/ebean-core/src/test/java/org/tests/model/interfaces/SelfManyMany.java b/ebean-test/src/test/java/org/tests/model/interfaces/SelfManyMany.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/model/interfaces/SelfManyMany.java
rename to ebean-test/src/test/java/org/tests/model/interfaces/SelfManyMany.java
index 6cfc52193..0950feaab 100644
--- a/ebean-core/src/test/java/org/tests/model/interfaces/SelfManyMany.java
+++ b/ebean-test/src/test/java/org/tests/model/interfaces/SelfManyMany.java
@@ -1,10 +1,6 @@
 package org.tests.model.interfaces;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/interfaces/TestSelfMany.java b/ebean-test/src/test/java/org/tests/model/interfaces/TestSelfMany.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/interfaces/TestSelfMany.java
rename to ebean-test/src/test/java/org/tests/model/interfaces/TestSelfMany.java
index e12c47cfd..ec164715d 100644
--- a/ebean-core/src/test/java/org/tests/model/interfaces/TestSelfMany.java
+++ b/ebean-test/src/test/java/org/tests/model/interfaces/TestSelfMany.java
@@ -2,7 +2,7 @@ package org.tests.model.interfaces;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class TestSelfMany extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/model/interfaces/TestTargetEntity.java b/ebean-test/src/test/java/org/tests/model/interfaces/TestTargetEntity.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/model/interfaces/TestTargetEntity.java
rename to ebean-test/src/test/java/org/tests/model/interfaces/TestTargetEntity.java
index 9db04f045..974d7aeef 100644
--- a/ebean-core/src/test/java/org/tests/model/interfaces/TestTargetEntity.java
+++ b/ebean-test/src/test/java/org/tests/model/interfaces/TestTargetEntity.java
@@ -2,7 +2,7 @@ package org.tests.model.interfaces;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/ESomeConvertType.java b/ebean-test/src/test/java/org/tests/model/ivo/ESomeConvertType.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ivo/ESomeConvertType.java
rename to ebean-test/src/test/java/org/tests/model/ivo/ESomeConvertType.java
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/Money.java b/ebean-test/src/test/java/org/tests/model/ivo/Money.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ivo/Money.java
rename to ebean-test/src/test/java/org/tests/model/ivo/Money.java
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/Oid.java b/ebean-test/src/test/java/org/tests/model/ivo/Oid.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ivo/Oid.java
rename to ebean-test/src/test/java/org/tests/model/ivo/Oid.java
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/Segment.java b/ebean-test/src/test/java/org/tests/model/ivo/Segment.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ivo/Segment.java
rename to ebean-test/src/test/java/org/tests/model/ivo/Segment.java
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/SysTime.java b/ebean-test/src/test/java/org/tests/model/ivo/SysTime.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ivo/SysTime.java
rename to ebean-test/src/test/java/org/tests/model/ivo/SysTime.java
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/converter/AnEnumType.java b/ebean-test/src/test/java/org/tests/model/ivo/converter/AnEnumType.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ivo/converter/AnEnumType.java
rename to ebean-test/src/test/java/org/tests/model/ivo/converter/AnEnumType.java
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/converter/AnEnumTypeConvert.java b/ebean-test/src/test/java/org/tests/model/ivo/converter/AnEnumTypeConvert.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ivo/converter/AnEnumTypeConvert.java
rename to ebean-test/src/test/java/org/tests/model/ivo/converter/AnEnumTypeConvert.java
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/converter/MoneyTypeConverter.java b/ebean-test/src/test/java/org/tests/model/ivo/converter/MoneyTypeConverter.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ivo/converter/MoneyTypeConverter.java
rename to ebean-test/src/test/java/org/tests/model/ivo/converter/MoneyTypeConverter.java
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/converter/OidTypeConverter.java b/ebean-test/src/test/java/org/tests/model/ivo/converter/OidTypeConverter.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ivo/converter/OidTypeConverter.java
rename to ebean-test/src/test/java/org/tests/model/ivo/converter/OidTypeConverter.java
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/converter/SysTimeConverter.java b/ebean-test/src/test/java/org/tests/model/ivo/converter/SysTimeConverter.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/ivo/converter/SysTimeConverter.java
rename to ebean-test/src/test/java/org/tests/model/ivo/converter/SysTimeConverter.java
diff --git a/ebean-core/src/test/java/org/tests/model/ivo/test/TestAttributeConverter.java b/ebean-test/src/test/java/org/tests/model/ivo/test/TestAttributeConverter.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/model/ivo/test/TestAttributeConverter.java
rename to ebean-test/src/test/java/org/tests/model/ivo/test/TestAttributeConverter.java
index d1396dde4..57a4d97ad 100644
--- a/ebean-core/src/test/java/org/tests/model/ivo/test/TestAttributeConverter.java
+++ b/ebean-test/src/test/java/org/tests/model/ivo/test/TestAttributeConverter.java
@@ -2,7 +2,7 @@ package org.tests.model.ivo.test;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.ivo.ESomeConvertType;
 import org.tests.model.ivo.Money;
 
diff --git a/ebean-core/src/test/java/org/tests/model/joda/BasicJodaEntity.java b/ebean-test/src/test/java/org/tests/model/joda/BasicJodaEntity.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/model/joda/BasicJodaEntity.java
rename to ebean-test/src/test/java/org/tests/model/joda/BasicJodaEntity.java
index 78ce42408..66bb6db7a 100644
--- a/ebean-core/src/test/java/org/tests/model/joda/BasicJodaEntity.java
+++ b/ebean-test/src/test/java/org/tests/model/joda/BasicJodaEntity.java
@@ -1,7 +1,7 @@
 package org.tests.model.joda;
 
-import io.ebean.annotation.CreatedTimestamp;
-import io.ebean.annotation.UpdatedTimestamp;
+import io.ebean.annotation.WhenCreated;
+import io.ebean.annotation.WhenModified;
 import org.joda.time.DateTime;
 import org.joda.time.LocalDate;
 import org.joda.time.LocalDateTime;
@@ -19,10 +19,10 @@ public class BasicJodaEntity {
 
   String name;
 
-  @CreatedTimestamp
+  @WhenCreated
   LocalDateTime created;
 
-  @UpdatedTimestamp
+  @WhenModified
   DateTime updated;
 
   Period period;
diff --git a/ebean-core/src/test/java/org/tests/model/joda/TestJodaInsertUpdate.java b/ebean-test/src/test/java/org/tests/model/joda/TestJodaInsertUpdate.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/model/joda/TestJodaInsertUpdate.java
rename to ebean-test/src/test/java/org/tests/model/joda/TestJodaInsertUpdate.java
index b29737060..127eb6162 100644
--- a/ebean-core/src/test/java/org/tests/model/joda/TestJodaInsertUpdate.java
+++ b/ebean-test/src/test/java/org/tests/model/joda/TestJodaInsertUpdate.java
@@ -6,12 +6,10 @@ import org.joda.time.DateTime;
 import org.joda.time.LocalDate;
 import org.joda.time.LocalDateTime;
 import org.joda.time.Period;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestJodaInsertUpdate extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/model/json/BasicJacksonType.java b/ebean-test/src/test/java/org/tests/model/json/BasicJacksonType.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/BasicJacksonType.java
rename to ebean-test/src/test/java/org/tests/model/json/BasicJacksonType.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicHstore.java b/ebean-test/src/test/java/org/tests/model/json/EBasicHstore.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicHstore.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicHstore.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonJackson.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonJackson.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonJackson.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonJackson.java
index bdfa43add..6a84ff2f7 100644
--- a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonJackson.java
+++ b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonJackson.java
@@ -7,12 +7,7 @@ import io.ebean.annotation.DbJsonB;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Version;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 @Entity
 public class EBasicJsonJackson {
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonJackson2.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonJackson2.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonJackson2.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonJackson2.java
index 45a305105..8e801113c 100644
--- a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonJackson2.java
+++ b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonJackson2.java
@@ -7,12 +7,7 @@ import io.ebean.annotation.DbJsonB;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Version;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 @Entity
 public class EBasicJsonJackson2 {
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonJackson3.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonJackson3.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonJackson3.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonJackson3.java
index cee12d9e7..225939bb7 100644
--- a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonJackson3.java
+++ b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonJackson3.java
@@ -2,7 +2,6 @@ package org.tests.model.json;
 
 import io.ebean.Model;
 import io.ebean.annotation.DbJson;
-import io.ebean.annotation.MutationDetection;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonList.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonList.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonList.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonList.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonMap.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonMap.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonMap.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonMap.java
index 520016df9..30e0f502f 100644
--- a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonMap.java
+++ b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonMap.java
@@ -2,11 +2,7 @@ package org.tests.model.json;
 
 import io.ebean.annotation.DbJson;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonMapBlob.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonMapBlob.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonMapBlob.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonMapBlob.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonMapClob.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonMapClob.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonMapClob.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonMapClob.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonMapDetail.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonMapDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonMapDetail.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonMapDetail.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonMapJsonB.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonMapJsonB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonMapJsonB.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonMapJsonB.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonMapVarchar.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonMapVarchar.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonMapVarchar.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonMapVarchar.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonMulti.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonMulti.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonMulti.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonMulti.java
index 23dcd33d9..7e294914d 100644
--- a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonMulti.java
+++ b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonMulti.java
@@ -2,13 +2,11 @@ package org.tests.model.json;
 
 import io.ebean.Model;
 import io.ebean.annotation.DbJson;
-import io.ebean.annotation.MutationDetection;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Version;
 
-import static io.ebean.annotation.MutationDetection.NONE;
 import static io.ebean.annotation.MutationDetection.SOURCE;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonNode.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonNode.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonNode.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonNode.java
index 7488ac4f8..97ce8bb81 100644
--- a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonNode.java
+++ b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonNode.java
@@ -1,7 +1,7 @@
 package org.tests.model.json;
 
-import io.ebean.annotation.DbJson;
 import com.fasterxml.jackson.databind.JsonNode;
+import io.ebean.annotation.DbJson;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonNodeBlob.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonNodeBlob.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonNodeBlob.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonNodeBlob.java
index 844ab3569..527dcdfd0 100644
--- a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonNodeBlob.java
+++ b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonNodeBlob.java
@@ -1,8 +1,8 @@
 package org.tests.model.json;
 
+import com.fasterxml.jackson.databind.JsonNode;
 import io.ebean.annotation.DbJson;
 import io.ebean.annotation.DbJsonType;
-import com.fasterxml.jackson.databind.JsonNode;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonNodeJsonB.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonNodeJsonB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonNodeJsonB.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonNodeJsonB.java
index d0f7016a3..f8f8392dc 100644
--- a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonNodeJsonB.java
+++ b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonNodeJsonB.java
@@ -1,7 +1,7 @@
 package org.tests.model.json;
 
-import io.ebean.annotation.DbJsonB;
 import com.fasterxml.jackson.databind.JsonNode;
+import io.ebean.annotation.DbJsonB;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonNodeVarchar.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonNodeVarchar.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonNodeVarchar.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonNodeVarchar.java
index 8acd2c016..c8b2939e3 100644
--- a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonNodeVarchar.java
+++ b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonNodeVarchar.java
@@ -1,8 +1,8 @@
 package org.tests.model.json;
 
+import com.fasterxml.jackson.databind.JsonNode;
 import io.ebean.annotation.DbJson;
 import io.ebean.annotation.DbJsonType;
-import com.fasterxml.jackson.databind.JsonNode;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicJsonUnmapped.java b/ebean-test/src/test/java/org/tests/model/json/EBasicJsonUnmapped.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicJsonUnmapped.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicJsonUnmapped.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicOldValue.java b/ebean-test/src/test/java/org/tests/model/json/EBasicOldValue.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicOldValue.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicOldValue.java
index 37e805412..614758a1c 100644
--- a/ebean-core/src/test/java/org/tests/model/json/EBasicOldValue.java
+++ b/ebean-test/src/test/java/org/tests/model/json/EBasicOldValue.java
@@ -1,13 +1,11 @@
 package org.tests.model.json;
 
+import com.fasterxml.jackson.databind.JsonNode;
 import io.ebean.annotation.DbArray;
 import io.ebean.annotation.DbJson;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
-
-import com.fasterxml.jackson.databind.JsonNode;
-
 import java.util.*;
 
 import static io.ebean.annotation.MutationDetection.SOURCE;
@@ -25,35 +23,35 @@ public class EBasicOldValue {
 
   @DbJson(mutationDetection = SOURCE)
   Set<Long> longSet = new LinkedHashSet<>();
-  
+
   @DbJson(mutationDetection = SOURCE)
   Set<Integer> intSet = new LinkedHashSet<>();
-  
+
   @DbJson(mutationDetection = SOURCE)
   List<String> stringList = new ArrayList<>();
 
   @DbJson(mutationDetection = SOURCE)
   List<Long> longList = new ArrayList<>();
-  
+
   @DbJson(mutationDetection = SOURCE)
   List<Integer> intList = new ArrayList<>();
-  
+
   @DbJson(mutationDetection = SOURCE)
   Map<String, Object> objectMap = new LinkedHashMap<>();
 
   @DbJson(mutationDetection = SOURCE)
   Map<String, Long> longMap = new LinkedHashMap<>();
-  
+
   @DbJson(mutationDetection = SOURCE)
   Map<String, Integer> intMap = new LinkedHashMap<>();
 
   @DbJson(mutationDetection = SOURCE)
   JsonNode jsonNode;
-  
+
   @DbArray()
   List<String> stringArr = new ArrayList<>();
-  
-  
+
+
   public Long getId() {
     return id;
   }
@@ -141,15 +139,15 @@ public class EBasicOldValue {
   public void setIntMap(Map<String, Integer> intMap) {
     this.intMap = intMap;
   }
-  
+
   public JsonNode getJsonNode() {
     return jsonNode;
   }
-  
+
   public void setJsonNode(JsonNode jsonNode) {
     this.jsonNode = jsonNode;
   }
-  
+
   public List<String> getStringArr() {
     return stringArr;
   }
diff --git a/ebean-core/src/test/java/org/tests/model/json/EBasicPlain.java b/ebean-test/src/test/java/org/tests/model/json/EBasicPlain.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/EBasicPlain.java
rename to ebean-test/src/test/java/org/tests/model/json/EBasicPlain.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/LongJacksonType.java b/ebean-test/src/test/java/org/tests/model/json/LongJacksonType.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/LongJacksonType.java
rename to ebean-test/src/test/java/org/tests/model/json/LongJacksonType.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/PlainBean.java b/ebean-test/src/test/java/org/tests/model/json/PlainBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/PlainBean.java
rename to ebean-test/src/test/java/org/tests/model/json/PlainBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/PlainBeanDirtyAware.java b/ebean-test/src/test/java/org/tests/model/json/PlainBeanDirtyAware.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/PlainBeanDirtyAware.java
rename to ebean-test/src/test/java/org/tests/model/json/PlainBeanDirtyAware.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/StringJacksonType.java b/ebean-test/src/test/java/org/tests/model/json/StringJacksonType.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/json/StringJacksonType.java
rename to ebean-test/src/test/java/org/tests/model/json/StringJacksonType.java
diff --git a/ebean-core/src/test/java/org/tests/model/json/TestJacksonPlainBean.java b/ebean-test/src/test/java/org/tests/model/json/TestJacksonPlainBean.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/json/TestJacksonPlainBean.java
rename to ebean-test/src/test/java/org/tests/model/json/TestJacksonPlainBean.java
index b2237731d..e84d82dc3 100644
--- a/ebean-core/src/test/java/org/tests/model/json/TestJacksonPlainBean.java
+++ b/ebean-test/src/test/java/org/tests/model/json/TestJacksonPlainBean.java
@@ -1,12 +1,13 @@
 package org.tests.model.json;
 
+import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebeantest.LoggedSql;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class TestJacksonPlainBean {
+public class TestJacksonPlainBean extends BaseTestCase {
 
   @Test
   public void insertNullStayNull() {
@@ -28,8 +29,9 @@ public class TestJacksonPlainBean {
     final EBasicPlain found = DB.find(EBasicPlain.class, bean.getId());
     found.setAttr("n2");
     DB.save(found);
-    expectedSql(1, "update ebasic_plain set attr=?, version=? where id=? and version=?");
-
+    if (!isMySql()) {
+      expectedSql(1, "update ebasic_plain set attr=?, version=? where id=? and version=?");
+    }
     LoggedSql.stop();
   }
 
@@ -46,7 +48,11 @@ public class TestJacksonPlainBean {
     bean.setPlainBean2(new PlainBean("bar", 27));
 
     DB.save(bean);
-    expectedSql(0, "insert into ebasic_plain (attr, plain_bean, plain_bean2, version) values (?,?,?,?)");
+    if (isSqlServer()) {
+      expectedSql(0, "insert into ebasic_plain (id, attr, plain_bean, plain_bean2, version) values (?,?,?,?,?)");
+    } else {
+      expectedSql(0, "insert into ebasic_plain (attr, plain_bean, plain_bean2, version) values (?,?,?,?)");
+    }
 
     // inserted plainBean has not been mutated
     bean.setAttr("attr1");
diff --git a/ebean-core/src/test/java/org/tests/model/lazywithcache/ChildWithCache.java b/ebean-test/src/test/java/org/tests/model/lazywithcache/ChildWithCache.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/model/lazywithcache/ChildWithCache.java
rename to ebean-test/src/test/java/org/tests/model/lazywithcache/ChildWithCache.java
index d15c36d49..ff591d427 100644
--- a/ebean-core/src/test/java/org/tests/model/lazywithcache/ChildWithCache.java
+++ b/ebean-test/src/test/java/org/tests/model/lazywithcache/ChildWithCache.java
@@ -1,12 +1,12 @@
 package org.tests.model.lazywithcache;
 
+import io.ebean.annotation.Cache;
+
 import javax.persistence.Basic;
 import javax.persistence.Entity;
 import javax.persistence.FetchType;
 import javax.persistence.Id;
 
-import io.ebean.annotation.Cache;
-
 /**
  * Class with @Cache and lazy load property.
  *
@@ -16,15 +16,15 @@ import io.ebean.annotation.Cache;
 @Entity
 @Cache(enableQueryCache = true)
 public class ChildWithCache {
-  
+
   @Id
   Long id;
 
   String name;
-  
+
   @Basic(fetch = FetchType.LAZY)
   String address;
-  
+
   public Long getId() {
     return id;
   }
@@ -32,7 +32,7 @@ public class ChildWithCache {
   public void setId(Long id) {
     this.id = id;
   }
-  
+
   public String getName() {
     return name;
   }
@@ -40,11 +40,11 @@ public class ChildWithCache {
   public void setName(String name) {
     this.name = name;
   }
-  
+
   public void setAddress(String address) {
     this.address = address;
   }
-  
+
   public String getAddress() {
     return address;
   }
diff --git a/ebean-core/src/test/java/org/tests/model/lazywithcache/ParentA.java b/ebean-test/src/test/java/org/tests/model/lazywithcache/ParentA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/lazywithcache/ParentA.java
rename to ebean-test/src/test/java/org/tests/model/lazywithcache/ParentA.java
diff --git a/ebean-core/src/test/java/org/tests/model/lazywithcache/ParentB.java b/ebean-test/src/test/java/org/tests/model/lazywithcache/ParentB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/lazywithcache/ParentB.java
rename to ebean-test/src/test/java/org/tests/model/lazywithcache/ParentB.java
diff --git a/ebean-core/src/test/java/org/tests/model/lazywithcache/TestWithCacheAndLazyLoad.java b/ebean-test/src/test/java/org/tests/model/lazywithcache/TestWithCacheAndLazyLoad.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/model/lazywithcache/TestWithCacheAndLazyLoad.java
rename to ebean-test/src/test/java/org/tests/model/lazywithcache/TestWithCacheAndLazyLoad.java
index ce5d35b26..380f82c5d 100644
--- a/ebean-core/src/test/java/org/tests/model/lazywithcache/TestWithCacheAndLazyLoad.java
+++ b/ebean-test/src/test/java/org/tests/model/lazywithcache/TestWithCacheAndLazyLoad.java
@@ -1,9 +1,8 @@
 package org.tests.model.lazywithcache;
 
-import org.junit.Test;
-
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/model/lazywithid/Looney.java b/ebean-test/src/test/java/org/tests/model/lazywithid/Looney.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/lazywithid/Looney.java
rename to ebean-test/src/test/java/org/tests/model/lazywithid/Looney.java
diff --git a/ebean-core/src/test/java/org/tests/model/lazywithid/TestColumnIdName.java b/ebean-test/src/test/java/org/tests/model/lazywithid/TestColumnIdName.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/model/lazywithid/TestColumnIdName.java
rename to ebean-test/src/test/java/org/tests/model/lazywithid/TestColumnIdName.java
index f230cec9e..6c1f8ea58 100644
--- a/ebean-core/src/test/java/org/tests/model/lazywithid/TestColumnIdName.java
+++ b/ebean-test/src/test/java/org/tests/model/lazywithid/TestColumnIdName.java
@@ -1,8 +1,8 @@
 package org.tests.model.lazywithid;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -14,9 +14,9 @@ public class TestColumnIdName extends BaseTestCase {
 
     Tune tune = new Tune();
     tune.getLoonies().add(new Looney("Taz"));
-    Ebean.save(tune);
+    DB.save(tune);
 
-    final List<Tune> fetchedCollection = Ebean.find(Tune.class).findList();
+    final List<Tune> fetchedCollection = DB.find(Tune.class).findList();
 
     assertThat(fetchedCollection).hasSize(1);
     assertThat(fetchedCollection.get(0).getLoonies()).hasSize(1);
diff --git a/ebean-core/src/test/java/org/tests/model/lazywithid/Tune.java b/ebean-test/src/test/java/org/tests/model/lazywithid/Tune.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/model/lazywithid/Tune.java
rename to ebean-test/src/test/java/org/tests/model/lazywithid/Tune.java
index 93c374d03..65930791f 100644
--- a/ebean-core/src/test/java/org/tests/model/lazywithid/Tune.java
+++ b/ebean-test/src/test/java/org/tests/model/lazywithid/Tune.java
@@ -1,15 +1,10 @@
 package org.tests.model.lazywithid;
 
-import java.util.List;
-
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-
 import io.ebean.common.BeanList;
 
+import javax.persistence.*;
+import java.util.List;
+
 @Entity
 public class Tune {
 
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/DCredit.java b/ebean-test/src/test/java/org/tests/model/m2m/DCredit.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/m2m/DCredit.java
rename to ebean-test/src/test/java/org/tests/model/m2m/DCredit.java
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/DRol.java b/ebean-test/src/test/java/org/tests/model/m2m/DRol.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/m2m/DRol.java
rename to ebean-test/src/test/java/org/tests/model/m2m/DRol.java
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/DRot.java b/ebean-test/src/test/java/org/tests/model/m2m/DRot.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/m2m/DRot.java
rename to ebean-test/src/test/java/org/tests/model/m2m/DRot.java
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/MailBox.java b/ebean-test/src/test/java/org/tests/model/m2m/MailBox.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/m2m/MailBox.java
rename to ebean-test/src/test/java/org/tests/model/m2m/MailBox.java
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/MailUser.java b/ebean-test/src/test/java/org/tests/model/m2m/MailUser.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/m2m/MailUser.java
rename to ebean-test/src/test/java/org/tests/model/m2m/MailUser.java
index 3dba93d6b..2f51929df 100644
--- a/ebean-core/src/test/java/org/tests/model/m2m/MailUser.java
+++ b/ebean-test/src/test/java/org/tests/model/m2m/MailUser.java
@@ -1,11 +1,6 @@
 package org.tests.model.m2m;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/MnyA.java b/ebean-test/src/test/java/org/tests/model/m2m/MnyA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/m2m/MnyA.java
rename to ebean-test/src/test/java/org/tests/model/m2m/MnyA.java
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/MnyB.java b/ebean-test/src/test/java/org/tests/model/m2m/MnyB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/m2m/MnyB.java
rename to ebean-test/src/test/java/org/tests/model/m2m/MnyB.java
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/MnyC.java b/ebean-test/src/test/java/org/tests/model/m2m/MnyC.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/m2m/MnyC.java
rename to ebean-test/src/test/java/org/tests/model/m2m/MnyC.java
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/MnyEdge.java b/ebean-test/src/test/java/org/tests/model/m2m/MnyEdge.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/m2m/MnyEdge.java
rename to ebean-test/src/test/java/org/tests/model/m2m/MnyEdge.java
index 2e86cb9df..28e7636a4 100644
--- a/ebean-core/src/test/java/org/tests/model/m2m/MnyEdge.java
+++ b/ebean-test/src/test/java/org/tests/model/m2m/MnyEdge.java
@@ -1,11 +1,11 @@
 package org.tests.model.m2m;
 
+import io.ebean.annotation.Index;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.ManyToOne;
 
-import io.ebean.annotation.Index;
-
 @Entity
 @Index(unique = true, columnNames = { "from_id", "to_id" })
 @Index(unique = true, columnNames = { "to_id", "from_id" })
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/MnyNode.java b/ebean-test/src/test/java/org/tests/model/m2m/MnyNode.java
similarity index 95%
rename from ebean-core/src/test/java/org/tests/model/m2m/MnyNode.java
rename to ebean-test/src/test/java/org/tests/model/m2m/MnyNode.java
index 3f9a8d347..edbd87cc0 100644
--- a/ebean-core/src/test/java/org/tests/model/m2m/MnyNode.java
+++ b/ebean-test/src/test/java/org/tests/model/m2m/MnyNode.java
@@ -1,15 +1,10 @@
 package org.tests.model.m2m;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
-
 import io.ebean.annotation.Identity;
 import io.ebean.annotation.Platform;
 import io.ebean.annotation.Where;
 
+import javax.persistence.*;
 import java.util.List;
 
 @Identity(start = 1000)
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/MnyTopic.java b/ebean-test/src/test/java/org/tests/model/m2m/MnyTopic.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/m2m/MnyTopic.java
rename to ebean-test/src/test/java/org/tests/model/m2m/MnyTopic.java
index 02e751024..e4710130c 100644
--- a/ebean-core/src/test/java/org/tests/model/m2m/MnyTopic.java
+++ b/ebean-test/src/test/java/org/tests/model/m2m/MnyTopic.java
@@ -1,11 +1,6 @@
 package org.tests.model.m2m;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/Permission.java b/ebean-test/src/test/java/org/tests/model/m2m/Permission.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/m2m/Permission.java
rename to ebean-test/src/test/java/org/tests/model/m2m/Permission.java
index 517a56882..2bf201542 100644
--- a/ebean-core/src/test/java/org/tests/model/m2m/Permission.java
+++ b/ebean-test/src/test/java/org/tests/model/m2m/Permission.java
@@ -2,11 +2,7 @@ package org.tests.model.m2m;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.Set;
 import java.util.UUID;
 
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/Role.java b/ebean-test/src/test/java/org/tests/model/m2m/Role.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/m2m/Role.java
rename to ebean-test/src/test/java/org/tests/model/m2m/Role.java
index 0a2b13703..1b32e7ef9 100644
--- a/ebean-core/src/test/java/org/tests/model/m2m/Role.java
+++ b/ebean-test/src/test/java/org/tests/model/m2m/Role.java
@@ -1,13 +1,6 @@
 package org.tests.model.m2m;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToMany;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.Set;
 import java.util.UUID;
 
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/Tenant.java b/ebean-test/src/test/java/org/tests/model/m2m/Tenant.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/m2m/Tenant.java
rename to ebean-test/src/test/java/org/tests/model/m2m/Tenant.java
index 9a740f54a..32db7e352 100644
--- a/ebean-core/src/test/java/org/tests/model/m2m/Tenant.java
+++ b/ebean-test/src/test/java/org/tests/model/m2m/Tenant.java
@@ -1,12 +1,6 @@
 package org.tests.model.m2m;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.Set;
 import java.util.UUID;
 
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/TestM2MDoubleInsert.java b/ebean-test/src/test/java/org/tests/model/m2m/TestM2MDoubleInsert.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/m2m/TestM2MDoubleInsert.java
rename to ebean-test/src/test/java/org/tests/model/m2m/TestM2MDoubleInsert.java
index 1c59dbf3e..beb7566e4 100644
--- a/ebean-core/src/test/java/org/tests/model/m2m/TestM2MDoubleInsert.java
+++ b/ebean-test/src/test/java/org/tests/model/m2m/TestM2MDoubleInsert.java
@@ -1,7 +1,7 @@
 package org.tests.model.m2m;
 
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 public class TestM2MDoubleInsert {
 
@@ -18,6 +18,6 @@ public class TestM2MDoubleInsert {
 
     DRot rot = new DRot("rot");
     rot.getCroles().add(role);
-    Ebean.save(rot);
+    DB.save(rot);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/m2m/TestM2MWithWhere.java b/ebean-test/src/test/java/org/tests/model/m2m/TestM2MWithWhere.java
similarity index 95%
rename from ebean-core/src/test/java/org/tests/model/m2m/TestM2MWithWhere.java
rename to ebean-test/src/test/java/org/tests/model/m2m/TestM2MWithWhere.java
index da8d83dd5..0525c0896 100644
--- a/ebean-core/src/test/java/org/tests/model/m2m/TestM2MWithWhere.java
+++ b/ebean-test/src/test/java/org/tests/model/m2m/TestM2MWithWhere.java
@@ -1,16 +1,13 @@
 package org.tests.model.m2m;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.util.List;
-
-import org.junit.Test;
-import org.tests.model.m2m.MnyEdge;
-import org.tests.model.m2m.MnyNode;
-
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebeantest.LoggedSql;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests M2M with complex where queries.
@@ -108,8 +105,8 @@ public class TestM2MWithWhere extends BaseTestCase {
       sb.append("from = ").append(from).append(" |");
       for (int to = 1; to <= 5; to++) {
         MnyEdge edge = new MnyEdge();
-        edge.setFrom(DB.getReference(MnyNode.class, from));
-        edge.setTo(DB.getReference(MnyNode.class, to));
+        edge.setFrom(DB.reference(MnyNode.class, from));
+        edge.setTo(DB.reference(MnyNode.class, to));
         int flags = 0;
         if (from < to) {
           flags |= 1;
@@ -125,7 +122,7 @@ public class TestM2MWithWhere extends BaseTestCase {
     }
     // System.out.println(sb); dump the table
   }
-  
+
 
   @Test
   public void testWithDbTableName() {
diff --git a/ebean-core/src/test/java/org/tests/model/m2o/Addr.java b/ebean-test/src/test/java/org/tests/model/m2o/Addr.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/m2o/Addr.java
rename to ebean-test/src/test/java/org/tests/model/m2o/Addr.java
diff --git a/ebean-core/src/test/java/org/tests/model/m2o/Empl.java b/ebean-test/src/test/java/org/tests/model/m2o/Empl.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/m2o/Empl.java
rename to ebean-test/src/test/java/org/tests/model/m2o/Empl.java
index 6341bd725..bf9b5b2c7 100644
--- a/ebean-core/src/test/java/org/tests/model/m2o/Empl.java
+++ b/ebean-test/src/test/java/org/tests/model/m2o/Empl.java
@@ -1,10 +1,6 @@
 package org.tests.model.m2o;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/m2o/TestManyToOneAsOne.java b/ebean-test/src/test/java/org/tests/model/m2o/TestManyToOneAsOne.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/m2o/TestManyToOneAsOne.java
rename to ebean-test/src/test/java/org/tests/model/m2o/TestManyToOneAsOne.java
index eb993da93..269e9dd57 100644
--- a/ebean-core/src/test/java/org/tests/model/m2o/TestManyToOneAsOne.java
+++ b/ebean-test/src/test/java/org/tests/model/m2o/TestManyToOneAsOne.java
@@ -1,11 +1,11 @@
 package org.tests.model.m2o;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.annotation.Transactional;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -28,7 +28,7 @@ public class TestManyToOneAsOne extends BaseTestCase {
 
     Addr junk = new Addr();
     junk.setName("junk");
-    Ebean.save(junk);
+    DB.save(junk);
 
     Empl emp = new Empl();
     emp.setName("My Name");
@@ -37,17 +37,17 @@ public class TestManyToOneAsOne extends BaseTestCase {
     address.setName("home");
     emp.getAddresses().add(address);
 
-    // if I do an interim Ebean.save here it works
-    //Ebean.save(emp);
+    // if I do an interim DB.save here it works
+    //DB.save(emp);
     address.setEmployee(emp);
     emp.setDefaultAddress(address);
 
-    Ebean.save(emp);
+    DB.save(emp);
 
     assertThat(emp.getDefaultAddress().getId()).isNotNull();
     assertThat(address.getEmployee().getId()).isNotNull();
 
-    Empl foundEmpl = Ebean.find(Empl.class, emp.getId());
+    Empl foundEmpl = DB.find(Empl.class, emp.getId());
     assertThat(foundEmpl.getDefaultAddress().getId()).isEqualTo(address.getId());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/map/BeanMapOrphanRemovalTest.java b/ebean-test/src/test/java/org/tests/model/map/BeanMapOrphanRemovalTest.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/model/map/BeanMapOrphanRemovalTest.java
rename to ebean-test/src/test/java/org/tests/model/map/BeanMapOrphanRemovalTest.java
index 48288e7a3..089df1a94 100644
--- a/ebean-core/src/test/java/org/tests/model/map/BeanMapOrphanRemovalTest.java
+++ b/ebean-test/src/test/java/org/tests/model/map/BeanMapOrphanRemovalTest.java
@@ -1,7 +1,7 @@
 package org.tests.model.map;
 
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 import java.util.Map;
diff --git a/ebean-core/src/test/java/org/tests/model/map/MpRole.java b/ebean-test/src/test/java/org/tests/model/map/MpRole.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/map/MpRole.java
rename to ebean-test/src/test/java/org/tests/model/map/MpRole.java
diff --git a/ebean-core/src/test/java/org/tests/model/map/MpUser.java b/ebean-test/src/test/java/org/tests/model/map/MpUser.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/map/MpUser.java
rename to ebean-test/src/test/java/org/tests/model/map/MpUser.java
diff --git a/ebean-core/src/test/java/org/tests/model/mappedsuper/ASimpleBean.java b/ebean-test/src/test/java/org/tests/model/mappedsuper/ASimpleBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/mappedsuper/ASimpleBean.java
rename to ebean-test/src/test/java/org/tests/model/mappedsuper/ASimpleBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/mappedsuper/NotEnhancedMappedSuper.java b/ebean-test/src/test/java/org/tests/model/mappedsuper/NotEnhancedMappedSuper.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/mappedsuper/NotEnhancedMappedSuper.java
rename to ebean-test/src/test/java/org/tests/model/mappedsuper/NotEnhancedMappedSuper.java
diff --git a/ebean-core/src/test/java/org/tests/model/nofk/EFile2NoFk.java b/ebean-test/src/test/java/org/tests/model/nofk/EFile2NoFk.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/nofk/EFile2NoFk.java
rename to ebean-test/src/test/java/org/tests/model/nofk/EFile2NoFk.java
diff --git a/ebean-core/src/test/java/org/tests/model/nofk/EFileNoFk.java b/ebean-test/src/test/java/org/tests/model/nofk/EFileNoFk.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/nofk/EFileNoFk.java
rename to ebean-test/src/test/java/org/tests/model/nofk/EFileNoFk.java
diff --git a/ebean-core/src/test/java/org/tests/model/nofk/EUserNoFk.java b/ebean-test/src/test/java/org/tests/model/nofk/EUserNoFk.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/nofk/EUserNoFk.java
rename to ebean-test/src/test/java/org/tests/model/nofk/EUserNoFk.java
diff --git a/ebean-core/src/test/java/org/tests/model/nofk/EUserNoFkSoftDel.java b/ebean-test/src/test/java/org/tests/model/nofk/EUserNoFkSoftDel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/nofk/EUserNoFkSoftDel.java
rename to ebean-test/src/test/java/org/tests/model/nofk/EUserNoFkSoftDel.java
diff --git a/ebean-core/src/test/java/org/tests/model/nofk/Test2NoFk.java b/ebean-test/src/test/java/org/tests/model/nofk/Test2NoFk.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/nofk/Test2NoFk.java
rename to ebean-test/src/test/java/org/tests/model/nofk/Test2NoFk.java
index bf00656a8..f93459556 100644
--- a/ebean-core/src/test/java/org/tests/model/nofk/Test2NoFk.java
+++ b/ebean-test/src/test/java/org/tests/model/nofk/Test2NoFk.java
@@ -2,24 +2,23 @@ package org.tests.model.nofk;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import javax.persistence.EntityNotFoundException;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 // test that simulates relations with @formula
 public class Test2NoFk extends BaseTestCase {
 
-  @Before
+  @BeforeEach
   public void setup() {
     // Reset t
     DB.truncate(EFile2NoFk.class, EUserNoFk.class, EUserNoFkSoftDel.class);
@@ -29,24 +28,24 @@ public class Test2NoFk extends BaseTestCase {
     EUserNoFk root = new EUserNoFk();
     root.setUserId(1);
     root.setUserName("root");
-    Ebean.save(root);
+    DB.save(root);
 
     EUserNoFk nobody = new EUserNoFk();
     nobody.setUserId(2);
     nobody.setUserName("nobody");
-    Ebean.save(nobody);
+    DB.save(nobody);
 
 
     // Now build the same with the softDel flag.
     EUserNoFkSoftDel rootSoftDel = new EUserNoFkSoftDel();
     rootSoftDel.setUserId(1);
     rootSoftDel.setUserName("root");
-    Ebean.save(rootSoftDel);
+    DB.save(rootSoftDel);
 
     EUserNoFkSoftDel nobodySoftDel = new EUserNoFkSoftDel();
     nobodySoftDel.setUserId(2);
     nobodySoftDel.setUserName("nobody");
-    Ebean.save(nobodySoftDel);
+    DB.save(nobodySoftDel);
 
 
     EFile2NoFk bash = new EFile2NoFk();
@@ -58,7 +57,7 @@ public class Test2NoFk extends BaseTestCase {
     user501.setUserId(501);
     user501SoftDel.setUserId(501);
 
-    Ebean.save(bash);
+    DB.save(bash);
 
     // create relation to non existent user
     EFile2NoFk cmd = new EFile2NoFk();
@@ -66,11 +65,11 @@ public class Test2NoFk extends BaseTestCase {
     cmd.setFileName("java");
     cmd.setOwnerId(500);
 
-    Ebean.save(cmd);
+    DB.save(cmd);
 
-    assertThat(Ebean.find(EFile2NoFk.class).findCount()).isEqualTo(2);
-    assertThat(Ebean.find(EUserNoFk.class).findCount()).isEqualTo(2);
-    assertThat(Ebean.find(EUserNoFkSoftDel.class).findCount()).isEqualTo(2);
+    assertThat(DB.find(EFile2NoFk.class).findCount()).isEqualTo(2);
+    assertThat(DB.find(EUserNoFk.class).findCount()).isEqualTo(2);
+    assertThat(DB.find(EUserNoFkSoftDel.class).findCount()).isEqualTo(2);
 
     // We should have this data in the database:
     //
@@ -88,7 +87,7 @@ public class Test2NoFk extends BaseTestCase {
 
   @Test
   public void testLazyLoadFile() {
-    List<EFile2NoFk> files = Ebean.find(EFile2NoFk.class).findList();
+    List<EFile2NoFk> files = DB.find(EFile2NoFk.class).findList();
     assertThat(files).hasSize(2);
 
     EFile2NoFk file1 = files.get(0);
@@ -125,7 +124,7 @@ public class Test2NoFk extends BaseTestCase {
 
   @Test
   public void testEagerLoadFile() {
-    List<EFile2NoFk> files = Ebean.find(EFile2NoFk.class).fetch("owner").findList();
+    List<EFile2NoFk> files = DB.find(EFile2NoFk.class).fetch("owner").findList();
     assertThat(files).hasSize(2);
 
     EFile2NoFk file1 = files.get(0);
@@ -158,7 +157,7 @@ public class Test2NoFk extends BaseTestCase {
 
   @Test
   public void testLazyLoadFileSoftDel() {
-    List<EFile2NoFk> files = Ebean.find(EFile2NoFk.class).findList();
+    List<EFile2NoFk> files = DB.find(EFile2NoFk.class).findList();
     assertThat(files).hasSize(2);
 
     EFile2NoFk file1 = files.get(0);
@@ -195,7 +194,7 @@ public class Test2NoFk extends BaseTestCase {
 
   @Test
   public void testEagerLoadFileSoftDel() {
-    List<EFile2NoFk> files = Ebean.find(EFile2NoFk.class).fetch("ownerSoftDel").findList();
+    List<EFile2NoFk> files = DB.find(EFile2NoFk.class).fetch("ownerSoftDel").findList();
     assertThat(files).hasSize(2);
 
     EFile2NoFk file1 = files.get(0);
diff --git a/ebean-core/src/test/java/org/tests/model/nofk/TestNoFk.java b/ebean-test/src/test/java/org/tests/model/nofk/TestNoFk.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/nofk/TestNoFk.java
rename to ebean-test/src/test/java/org/tests/model/nofk/TestNoFk.java
index e9ed12dbe..e27df52db 100644
--- a/ebean-core/src/test/java/org/tests/model/nofk/TestNoFk.java
+++ b/ebean-test/src/test/java/org/tests/model/nofk/TestNoFk.java
@@ -2,30 +2,29 @@ package org.tests.model.nofk;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.SqlRow;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import javax.persistence.EntityNotFoundException;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestNoFk extends BaseTestCase {
 
-  @Before
+  @BeforeEach
   public void setup() {
     // Reset t
-    Ebean.find(EFileNoFk.class).delete();
-    Ebean.find(EUserNoFk.class).delete();
-    Ebean.find(EUserNoFkSoftDel.class).delete();
+    DB.find(EFileNoFk.class).delete();
+    DB.find(EUserNoFk.class).delete();
+    DB.find(EUserNoFkSoftDel.class).delete();
 
     DB.sqlUpdate("delete from efile_no_fk_euser_no_fk").execute();
     String tabName = isOracle() ? "efile_no_fk_euser_no_fk_soft_d" : "efile_no_fk_euser_no_fk_soft_del";
@@ -35,24 +34,24 @@ public class TestNoFk extends BaseTestCase {
     EUserNoFk root = new EUserNoFk();
     root.setUserId(1);
     root.setUserName("root");
-    Ebean.save(root);
+    DB.save(root);
 
     EUserNoFk nobody = new EUserNoFk();
     nobody.setUserId(2);
     nobody.setUserName("nobody");
-    Ebean.save(nobody);
+    DB.save(nobody);
 
 
     // Now build the same with the softDel flag.
     EUserNoFkSoftDel rootSoftDel = new EUserNoFkSoftDel();
     rootSoftDel.setUserId(1);
     rootSoftDel.setUserName("root");
-    Ebean.save(rootSoftDel);
+    DB.save(rootSoftDel);
 
     EUserNoFkSoftDel nobodySoftDel = new EUserNoFkSoftDel();
     nobodySoftDel.setUserId(2);
     nobodySoftDel.setUserName("nobody");
-    Ebean.save(nobodySoftDel);
+    DB.save(nobodySoftDel);
 
 
     EFileNoFk bash = new EFileNoFk();
@@ -71,7 +70,7 @@ public class TestNoFk extends BaseTestCase {
     bash.getEditorsSoftDel().add(nobodySoftDel);
     bash.getEditorsSoftDel().add(user501SoftDel);
 
-    Ebean.save(bash);
+    DB.save(bash);
 
     // create relation to non existent user
     EFileNoFk cmd = new EFileNoFk();
@@ -87,12 +86,12 @@ public class TestNoFk extends BaseTestCase {
     user500SoftDel.setUserName("not persisted");
     cmd.setOwnerSoftDel(user500SoftDel);
 
-    Ebean.save(cmd);
+    DB.save(cmd);
 
 
-    assertThat(Ebean.find(EFileNoFk.class).findCount()).isEqualTo(2);
-    assertThat(Ebean.find(EUserNoFk.class).findCount()).isEqualTo(2);
-    assertThat(Ebean.find(EUserNoFkSoftDel.class).findCount()).isEqualTo(2);
+    assertThat(DB.find(EFileNoFk.class).findCount()).isEqualTo(2);
+    assertThat(DB.find(EUserNoFk.class).findCount()).isEqualTo(2);
+    assertThat(DB.find(EUserNoFkSoftDel.class).findCount()).isEqualTo(2);
 
     SqlRow row = DB.sqlQuery("select count(*) as cnt from efile_no_fk_euser_no_fk").findOne();
     assertThat(row.getInteger("cnt")).isEqualTo(3);
@@ -112,7 +111,7 @@ public class TestNoFk extends BaseTestCase {
 
   @Test
   public void testLazyLoadFile() {
-    List<EFileNoFk> files = Ebean.find(EFileNoFk.class).findList();
+    List<EFileNoFk> files = DB.find(EFileNoFk.class).findList();
     assertThat(files).hasSize(2);
 
     EFileNoFk file1 = files.get(0);
@@ -148,7 +147,7 @@ public class TestNoFk extends BaseTestCase {
 
   @Test
   public void testEagerLoadFile() {
-    List<EFileNoFk> files = Ebean.find(EFileNoFk.class).fetch("owner").findList();
+    List<EFileNoFk> files = DB.find(EFileNoFk.class).fetch("owner").findList();
     assertThat(files).hasSize(2);
 
     EFileNoFk file1 = files.get(0);
@@ -181,7 +180,7 @@ public class TestNoFk extends BaseTestCase {
 
   @Test
   public void testLazyLoadOwner() {
-    List<EUserNoFk> owners = Ebean.find(EUserNoFk.class).findList();
+    List<EUserNoFk> owners = DB.find(EUserNoFk.class).findList();
     assertThat(owners).hasSize(2);
 
     EUserNoFk owner1 = owners.get(0);
@@ -201,7 +200,7 @@ public class TestNoFk extends BaseTestCase {
 
   @Test
   public void testEagerLoadOwner() {
-    List<EUserNoFk> owners = Ebean.find(EUserNoFk.class)
+    List<EUserNoFk> owners = DB.find(EUserNoFk.class)
       .fetch("files")
       .findList();
     assertThat(owners).hasSize(2);
@@ -223,7 +222,7 @@ public class TestNoFk extends BaseTestCase {
 
   @Test
   public void testLazyLoadFileSoftDel() {
-    List<EFileNoFk> files = Ebean.find(EFileNoFk.class).findList();
+    List<EFileNoFk> files = DB.find(EFileNoFk.class).findList();
     assertThat(files).hasSize(2);
 
     EFileNoFk file1 = files.get(0);
@@ -260,7 +259,7 @@ public class TestNoFk extends BaseTestCase {
 
   @Test
   public void testEagerLoadFileSoftDel() {
-    List<EFileNoFk> files = Ebean.find(EFileNoFk.class).fetch("ownerSoftDel").findList();
+    List<EFileNoFk> files = DB.find(EFileNoFk.class).fetch("ownerSoftDel").findList();
     assertThat(files).hasSize(2);
 
     EFileNoFk file1 = files.get(0);
@@ -292,7 +291,7 @@ public class TestNoFk extends BaseTestCase {
 
   @Test
   public void testLazyLoadOwnerSoftDel() {
-    List<EUserNoFkSoftDel> owners = Ebean.find(EUserNoFkSoftDel.class).findList();
+    List<EUserNoFkSoftDel> owners = DB.find(EUserNoFkSoftDel.class).findList();
     assertThat(owners).hasSize(2);
 
     EUserNoFkSoftDel owner1 = owners.get(0);
@@ -312,7 +311,7 @@ public class TestNoFk extends BaseTestCase {
 
   @Test
   public void testEagerLoadOwnerSoftDel() {
-    List<EUserNoFkSoftDel> owners = Ebean.find(EUserNoFkSoftDel.class)
+    List<EUserNoFkSoftDel> owners = DB.find(EUserNoFkSoftDel.class)
       .fetch("files")
       .findList();
     assertThat(owners).hasSize(2);
@@ -334,14 +333,14 @@ public class TestNoFk extends BaseTestCase {
 
 
   @Test
-  @Ignore("this would be a bonus task :)")
+  @Disabled("this would be a bonus task :)")
   public void testLazyLoadUser500() {
     // user 500 does not exist in DB
-    EUserNoFk owner = Ebean.find(EUserNoFk.class, 500);
+    EUserNoFk owner = DB.find(EUserNoFk.class, 500);
     assertThat(owner).isNull();
 
     // but there are files that are owned by #500
-    owner = Ebean.getReference(EUserNoFk.class, 500);
+    owner = DB.reference(EUserNoFk.class, 500);
     assertThat(owner.getUserId()).isEqualTo(500);
     // this does not work yet, because the executed select contains a join:
     // select t0.user_id, t1.file_name, t1.owner_user_id
@@ -360,9 +359,9 @@ public class TestNoFk extends BaseTestCase {
   }
 
   @Test
-  @Ignore("Bonus Task 2")
+  @Disabled("Bonus Task 2")
   public void testM2mLazyLoadFile() {
-    List<EFileNoFk> files = Ebean.find(EFileNoFk.class).findList();
+    List<EFileNoFk> files = DB.find(EFileNoFk.class).findList();
     assertThat(files).hasSize(2);
 
     EFileNoFk file1 = files.get(0);
diff --git a/ebean-core/src/test/java/org/tests/model/nofk/TestTruncate.java b/ebean-test/src/test/java/org/tests/model/nofk/TestTruncate.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/model/nofk/TestTruncate.java
rename to ebean-test/src/test/java/org/tests/model/nofk/TestTruncate.java
index bf22cb284..3e468714d 100644
--- a/ebean-core/src/test/java/org/tests/model/nofk/TestTruncate.java
+++ b/ebean-test/src/test/java/org/tests/model/nofk/TestTruncate.java
@@ -1,7 +1,7 @@
 package org.tests.model.nofk;
 
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/model/noid/NoIdBean.java b/ebean-test/src/test/java/org/tests/model/noid/NoIdBean.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/model/noid/NoIdBean.java
rename to ebean-test/src/test/java/org/tests/model/noid/NoIdBean.java
index 129f33757..b43c344a5 100644
--- a/ebean-core/src/test/java/org/tests/model/noid/NoIdBean.java
+++ b/ebean-test/src/test/java/org/tests/model/noid/NoIdBean.java
@@ -1,6 +1,6 @@
 package org.tests.model.noid;
 
-import io.ebean.annotation.CreatedTimestamp;
+import io.ebean.annotation.WhenCreated;
 
 import javax.persistence.Entity;
 import javax.persistence.Table;
@@ -14,7 +14,7 @@ public class NoIdBean {
 
   String subject;
 
-  @CreatedTimestamp
+  @WhenCreated
   Timestamp whenCreated;
 
   public String getName() {
diff --git a/ebean-core/src/test/java/org/tests/model/noid/TestInsertNoIdBean.java b/ebean-test/src/test/java/org/tests/model/noid/TestInsertNoIdBean.java
similarity index 53%
rename from ebean-core/src/test/java/org/tests/model/noid/TestInsertNoIdBean.java
rename to ebean-test/src/test/java/org/tests/model/noid/TestInsertNoIdBean.java
index b7257afcf..bc4b7c94a 100644
--- a/ebean-core/src/test/java/org/tests/model/noid/TestInsertNoIdBean.java
+++ b/ebean-test/src/test/java/org/tests/model/noid/TestInsertNoIdBean.java
@@ -1,26 +1,22 @@
 package org.tests.model.noid;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestInsertNoIdBean extends BaseTestCase {
 
   @Test
   public void testInsert() {
-
-
     NoIdBean bean = new NoIdBean();
     bean.setName("Rocky");
     bean.setSubject("Blowing up stuff");
 
-    Ebean.save(bean);
-
-    int rowCount = Ebean.find(NoIdBean.class).findCount();
-
-    assertTrue("rowCount:" + rowCount, rowCount > 0);
+    DB.save(bean);
 
+    int rowCount = DB.find(NoIdBean.class).findCount();
+    assertThat(rowCount).isGreaterThan(0);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/Account.java b/ebean-test/src/test/java/org/tests/model/onetoone/Account.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/Account.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/Account.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OCompany.java b/ebean-test/src/test/java/org/tests/model/onetoone/OCompany.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OCompany.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OCompany.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/ORoadShowMsg.java b/ebean-test/src/test/java/org/tests/model/onetoone/ORoadShowMsg.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/ORoadShowMsg.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/ORoadShowMsg.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoAone.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoAone.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoAone.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoAone.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoAtwo.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoAtwo.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoAtwo.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoAtwo.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoBChild.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoBChild.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoBChild.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoBChild.java
index 744b1fd6c..108c91a94 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/OtoBChild.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/OtoBChild.java
@@ -3,11 +3,7 @@ package org.tests.model.onetoone;
 import io.ebean.annotation.Identity;
 import io.ebean.annotation.IdentityGenerated;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.PrimaryKeyJoinColumn;
+import javax.persistence.*;
 
 @Identity(generated = IdentityGenerated.BY_DEFAULT)
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoBMaster.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoBMaster.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoBMaster.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoBMaster.java
index 43e968ef0..d9a694476 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/OtoBMaster.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/OtoBMaster.java
@@ -1,10 +1,6 @@
 package org.tests.model.onetoone;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
+import javax.persistence.*;
 
 @Entity
 public class OtoBMaster {
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoChild.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoChild.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoChild.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoChild.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoCust.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoCust.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoCust.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoCust.java
index 50f5efad6..49d6eb502 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/OtoCust.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/OtoCust.java
@@ -1,10 +1,6 @@
 package org.tests.model.onetoone;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class OtoCust {
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoCustAddress.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoCustAddress.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoCustAddress.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoCustAddress.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoMaster.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoMaster.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoMaster.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoMaster.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoPrime.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoPrime.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoPrime.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoPrime.java
index 33adbd04a..3c1cbc193 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/OtoPrime.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/OtoPrime.java
@@ -1,11 +1,6 @@
 package org.tests.model.onetoone;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.PrimaryKeyJoinColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class OtoPrime {
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoPrimeExtra.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoPrimeExtra.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoPrimeExtra.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoPrimeExtra.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoSdChild.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoSdChild.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoSdChild.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoSdChild.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoSdMaster.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoSdMaster.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoSdMaster.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoSdMaster.java
index 95e5f947c..6dea4f146 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/OtoSdMaster.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/OtoSdMaster.java
@@ -2,11 +2,7 @@ package org.tests.model.onetoone;
 
 import io.ebean.Finder;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class OtoSdMaster {
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoThMany.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoThMany.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoThMany.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoThMany.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoThOne.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoThOne.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoThOne.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoThOne.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoThTop.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoThTop.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoThTop.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoThTop.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoUBPrime.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoUBPrime.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoUBPrime.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoUBPrime.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoUBPrimeExtra.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoUBPrimeExtra.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoUBPrimeExtra.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoUBPrimeExtra.java
index 0a87366fa..df14dee01 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/OtoUBPrimeExtra.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/OtoUBPrimeExtra.java
@@ -1,10 +1,6 @@
 package org.tests.model.onetoone;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.PrimaryKeyJoinColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.UUID;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoUPrime.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoUPrime.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoUPrime.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoUPrime.java
index a8da23578..e4371304f 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/OtoUPrime.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/OtoUPrime.java
@@ -2,11 +2,7 @@ package org.tests.model.onetoone;
 
 import io.ebean.annotation.DbForeignKey;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.PrimaryKeyJoinColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.UUID;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoUPrimeExtra.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoUPrimeExtra.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoUPrimeExtra.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoUPrimeExtra.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoUser.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoUser.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoUser.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoUser.java
index dabab0825..58a9b06a9 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/OtoUser.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/OtoUser.java
@@ -1,12 +1,12 @@
 package org.tests.model.onetoone;
 
+import org.tests.model.BaseModel;
+
 import javax.persistence.CascadeType;
 import javax.persistence.Entity;
 import javax.persistence.OneToOne;
 import javax.persistence.Table;
 
-import org.tests.model.BaseModel;
-
 @Entity
 @Table(name = "oto_user_model")
 public class OtoUser extends BaseModel {
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/OtoUserOptional.java b/ebean-test/src/test/java/org/tests/model/onetoone/OtoUserOptional.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/OtoUserOptional.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/OtoUserOptional.java
index 65dd701b0..9b21ba440 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/OtoUserOptional.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/OtoUserOptional.java
@@ -1,10 +1,10 @@
 package org.tests.model.onetoone;
 
+import org.tests.model.BaseModel;
+
 import javax.persistence.Entity;
 import javax.persistence.Table;
 
-import org.tests.model.BaseModel;
-
 @Entity
 @Table(name = "oto_user_model_optional")
 public class OtoUserOptional extends BaseModel {
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneCascadeSave.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneCascadeSave.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneCascadeSave.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneCascadeSave.java
index eedfaa2fb..5bc9e5bc7 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneCascadeSave.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneCascadeSave.java
@@ -1,16 +1,15 @@
 package org.tests.model.onetoone;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestOneToOneCascadeSave extends BaseTestCase {
 
   @Test
   public void test() {
-
-
     OtoMaster master = new OtoMaster();
     master.setName("CName");
 
@@ -22,14 +21,13 @@ public class TestOneToOneCascadeSave extends BaseTestCase {
     // object if it is currently null so you don't need to do the extra
     // o.setCustomer(c);
 
-    Ebean.save(master);
+    DB.save(master);
 
-    Assert.assertNotNull(child.getId());
+    assertNotNull(child.getId());
 
-    OtoChild child2 = Ebean.find(OtoChild.class, child.getId());
+    OtoChild child2 = DB.find(OtoChild.class, child.getId());
     OtoMaster master2 = child2.getMaster();
-    Assert.assertNotNull(master2);
-
+    assertNotNull(master2);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneImportedPkNative.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneImportedPkNative.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneImportedPkNative.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneImportedPkNative.java
index f23e3ce39..8d7d33e66 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneImportedPkNative.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneImportedPkNative.java
@@ -1,11 +1,11 @@
 package org.tests.model.onetoone;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -23,9 +23,9 @@ public class TestOneToOneImportedPkNative extends BaseTestCase {
     master.setName("m2");
     master.setChild(child);
 
-    Ebean.save(master);
+    DB.save(master);
 
-    Query<OtoBMaster> query = Ebean.find(OtoBMaster.class)
+    Query<OtoBMaster> query = DB.find(OtoBMaster.class)
       //.select("name")
       .where().idEq(master.getId())
       .query();
@@ -38,13 +38,13 @@ public class TestOneToOneImportedPkNative extends BaseTestCase {
 
     assertThat(one).isNotNull();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     OtoBChild child1 = one.getChild();
     assertThat(child1).isNotNull();
     assertThat(child1.getChild()).isEqualTo("c1");
 
-    List<String> lazyLoadSql = LoggedSqlCollector.stop();
+    List<String> lazyLoadSql = LoggedSql.stop();
     assertThat(lazyLoadSql).hasSize(2);
     assertSql(lazyLoadSql.get(0)).contains("select t0.id, t0.name, t0.id from oto_bmaster t0 where t0.id = ?");
     assertSql(lazyLoadSql.get(1)).contains("select t0.master_id, t0.child, t0.master_id from oto_bchild t0 where t0.master_id = ?");
@@ -53,12 +53,12 @@ public class TestOneToOneImportedPkNative extends BaseTestCase {
   @Test
   public void native_with_o2oAndImportedPrimaryKey() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     server.find(OtoBMaster.class).delete();
 
     OtoBMaster one = new OtoBMaster();
     one.setName("hello");
-    Ebean.save(one);
+    DB.save(one);
 
     OtoBMaster m = server.findNative(OtoBMaster.class, "select * from oto_bmaster").findOne();
 
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneJoinColumn.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneJoinColumn.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneJoinColumn.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneJoinColumn.java
index 60d7eab3b..70db66096 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneJoinColumn.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneJoinColumn.java
@@ -1,8 +1,8 @@
 package org.tests.model.onetoone;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 public class TestOneToOneJoinColumn extends BaseTestCase {
 
@@ -14,7 +14,7 @@ public class TestOneToOneJoinColumn extends BaseTestCase {
     company.setCorpId("corp_id_1000000");
     msg.setCompany(company);
 
-    Ebean.save(msg);
-    Ebean.find(ORoadShowMsg.class, msg.getId());
+    DB.save(msg);
+    DB.find(ORoadShowMsg.class, msg.getId());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneManyDelete.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneManyDelete.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneManyDelete.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneManyDelete.java
index 6ba85879a..9876b6737 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneManyDelete.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneManyDelete.java
@@ -1,7 +1,7 @@
 package org.tests.model.onetoone;
 
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 public class TestOneToOneManyDelete {
 
@@ -24,9 +24,9 @@ public class TestOneToOneManyDelete {
       top.getManies().add(many);
     }
 
-    Ebean.save(top);
+    DB.save(top);
 
-    Ebean.delete(top);
+    DB.delete(top);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneOptionalRelationship.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneOptionalRelationship.java
similarity index 50%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneOptionalRelationship.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneOptionalRelationship.java
index c53205e48..15d390821 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneOptionalRelationship.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneOptionalRelationship.java
@@ -1,28 +1,28 @@
 package org.tests.model.onetoone;
 
 import io.ebean.BaseTestCase;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestOneToOneOptionalRelationship extends BaseTestCase {
 
   @Test
   public void test() {
-
     Account account = new Account();
     account.setName("AC234");
     account.save();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Account fetchedAccount = Account.find.byId(account.getId());
-    Assert.assertNotNull(fetchedAccount);
+    assertNotNull(fetchedAccount);
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
-    Assert.assertEquals(1, loggedSql.size());
+    List<String> loggedSql = LoggedSql.stop();
+    assertEquals(1, loggedSql.size());
 
     // select t0.id c0, t0.name c1, t0.version c2, t0.when_created c3, t0.when_updated c4, t1.id c5
     // from oto_account t0
@@ -30,8 +30,8 @@ public class TestOneToOneOptionalRelationship extends BaseTestCase {
     // where t0.id = ?
 
     String sql = trimSql(loggedSql.get(0), 1);
-    Assert.assertTrue(sql.contains("select t0.id, t0.name"));
-    Assert.assertTrue(sql.contains(" from oto_account t0 left join oto_user t1 on t1.account_id = t0.id where t0.id = ?"));
+    assertTrue(sql.contains("select t0.id, t0.name"));
+    assertTrue(sql.contains(" from oto_account t0 left join oto_user t1 on t1.account_id = t0.id where t0.id = ?"));
   }
 
 
@@ -47,17 +47,17 @@ public class TestOneToOneOptionalRelationship extends BaseTestCase {
     user.setAccount(account);
     user.save();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Account fetchedAccount = Account.find.byId(account.getId());
-    Assert.assertNotNull(fetchedAccount);
+    assertNotNull(fetchedAccount);
 
-    Assert.assertNotNull(fetchedAccount.getUser());
-    Assert.assertEquals(user.getId(), fetchedAccount.getUser().getId());
-    Assert.assertEquals(user.getName(), fetchedAccount.getUser().getName());
+    assertNotNull(fetchedAccount.getUser());
+    assertEquals(user.getId(), fetchedAccount.getUser().getId());
+    assertEquals(user.getName(), fetchedAccount.getUser().getName());
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
-    Assert.assertEquals(2, loggedSql.size());
+    List<String> loggedSql = LoggedSql.stop();
+    assertEquals(2, loggedSql.size());
 
     // select t0.id c0, t0.name c1, t0.version c2, t0.when_created c3, t0.when_updated c4, t1.id c5
     // from oto_account t0
@@ -65,11 +65,11 @@ public class TestOneToOneOptionalRelationship extends BaseTestCase {
     // where t0.id = ?
 
     String sql = trimSql(loggedSql.get(0), 1);
-    Assert.assertTrue(sql.contains("select t0.id, t0.name"));
-    Assert.assertTrue(sql.contains(" from oto_account t0 left join oto_user t1 on t1.account_id = t0.id where t0.id = ?"));
+    assertTrue(sql.contains("select t0.id, t0.name"));
+    assertTrue(sql.contains(" from oto_account t0 left join oto_user t1 on t1.account_id = t0.id where t0.id = ?"));
 
     String lazyLoadSql = trimSql(loggedSql.get(1), 5);
-    Assert.assertTrue(lazyLoadSql.contains("select t0.id, t0.name, t0.version, t0.when_created, t0.when_modified, t0.account_id from oto_user t0 where t0.id = ?"));
+    assertTrue(lazyLoadSql.contains("select t0.id, t0.name, t0.version, t0.when_created, t0.when_modified, t0.account_id from oto_user t0 where t0.id = ?"));
   }
 
 
@@ -85,17 +85,17 @@ public class TestOneToOneOptionalRelationship extends BaseTestCase {
     user.setAccount(account);
     user.save();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Account fetchedAccount = Account.find.query().fetch("user").setId(account.getId()).findOne();
-    Assert.assertNotNull(fetchedAccount);
+    assertNotNull(fetchedAccount);
 
-    Assert.assertNotNull(fetchedAccount.getUser());
-    Assert.assertEquals(user.getId(), fetchedAccount.getUser().getId());
-    Assert.assertEquals(user.getName(), fetchedAccount.getUser().getName());
+    assertNotNull(fetchedAccount.getUser());
+    assertEquals(user.getId(), fetchedAccount.getUser().getId());
+    assertEquals(user.getName(), fetchedAccount.getUser().getName());
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
-    Assert.assertEquals(1, loggedSql.size());
+    List<String> loggedSql = LoggedSql.stop();
+    assertEquals(1, loggedSql.size());
 
     // select t0.id c0, t0.name c1, t0.version c2, t0.when_created c3, t0.when_updated c4, t1.id c5
     // from oto_account t0
@@ -103,7 +103,7 @@ public class TestOneToOneOptionalRelationship extends BaseTestCase {
     // where t0.id = ?
 
     String sql = trimSql(loggedSql.get(0), 1);
-    Assert.assertTrue(sql.contains("select t0.id, t0.name"));
-    Assert.assertTrue(sql.contains(" from oto_account t0 left join oto_user t1 on t1.account_id = t0.id where t0.id = ?"));
+    assertTrue(sql.contains("select t0.id, t0.name"));
+    assertTrue(sql.contains(" from oto_account t0 left join oto_user t1 on t1.account_id = t0.id where t0.id = ?"));
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanRemove.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanRemove.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanRemove.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanRemove.java
index 7c0828c25..a15ba6a15 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanRemove.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanRemove.java
@@ -1,12 +1,11 @@
 package org.tests.model.onetoone;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -23,17 +22,17 @@ public class TestOneToOneOrphanRemove extends BaseTestCase {
     OtoCustAddress address = new OtoCustAddress("line1", "line2");
 
     jack.setAddress(address);
-    Ebean.save(jack);
+    DB.save(jack);
 
     // set new address
     OtoCustAddress address2 = new OtoCustAddress("other1", "other2");
     jack.setAddress(address2);
 
     // Fail do to uniqueness constraint
-    LoggedSqlCollector.start();
-    Ebean.save(jack);
+    LoggedSql.start();
+    DB.save(jack);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(5);
     assertSql(sql.get(0)).contains("delete from oto_cust_address where aid=? and version=?");
     assertSqlBind(sql.get(1));
@@ -42,15 +41,15 @@ public class TestOneToOneOrphanRemove extends BaseTestCase {
     assertThat(sql.get(4)).contains("-- bind(");
 
     jack.setAddress(null);
-    Ebean.save(jack);
+    DB.save(jack);
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("delete from oto_cust_address where aid=? and version=?");
     assertSqlBind(sql.get(1));
     assertSql(sql.get(2)).contains("update oto_cust set version=? where cid=? and version=?");
 
-    OtoCustAddress foundAddress = Ebean.find(OtoCustAddress.class, address2.getAid());
+    OtoCustAddress foundAddress = DB.find(OtoCustAddress.class, address2.getAid());
     assertThat(foundAddress).isNull();
   }
 
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanStringId.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanStringId.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanStringId.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanStringId.java
index 6867177ed..14051b5e4 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanStringId.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneOrphanStringId.java
@@ -1,9 +1,9 @@
 package org.tests.model.onetoone;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -15,24 +15,24 @@ public class TestOneToOneOrphanStringId extends BaseTestCase {
   public void test_updateInsert() {
 
     OtoAtwo b = new OtoAtwo("b1", "b test");
-    Ebean.save(b);
+    DB.save(b);
 
     OtoAone a = new OtoAone("a1", "a test");
     b.setAone(a);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.save(b);
+    DB.save(b);
 
-    List<String> update = LoggedSqlCollector.current();
+    List<String> update = LoggedSql.collect();
     assertThat(update).hasSize(3);
     assertThat(update.get(0)).contains("insert into oto_aone");
     assertSqlBind(update.get(1));
     assertThat(update.get(2)).contains("update oto_atwo set aone_id=? where id=?");
 
-    Ebean.delete(b);
+    DB.delete(b);
 
-    List<String> deletes = LoggedSqlCollector.stop();
+    List<String> deletes = LoggedSql.stop();
     assertThat(deletes).hasSize(2);
     assertThat(deletes.get(0)).contains("delete from oto_atwo");
     assertThat(deletes.get(1)).contains("delete from oto_aone");
@@ -46,19 +46,19 @@ public class TestOneToOneOrphanStringId extends BaseTestCase {
 
     b.setAone(a);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.save(b);
+    DB.save(b);
 
-    List<String> inserts = LoggedSqlCollector.current();
+    List<String> inserts = LoggedSql.collect();
     assertThat(inserts).hasSize(3);
     assertThat(inserts.get(0)).contains("insert into oto_aone");
     assertSqlBind(inserts.get(1));
     assertThat(inserts.get(2)).contains("insert into oto_atwo");
 
-    Ebean.delete(b);
+    DB.delete(b);
 
-    List<String> deletes = LoggedSqlCollector.stop();
+    List<String> deletes = LoggedSql.stop();
     assertThat(deletes).hasSize(2);
     assertThat(deletes.get(0)).contains("delete from oto_atwo");
     assertThat(deletes.get(1)).contains("delete from oto_aone");
@@ -68,20 +68,20 @@ public class TestOneToOneOrphanStringId extends BaseTestCase {
   public void test_remove() {
 
     OtoAtwo b = new OtoAtwo("b3", "b test");
-    Ebean.save(b);
+    DB.save(b);
 
     OtoAone a = new OtoAone("a3", "a test");
     b.setAone(a);
 
-    Ebean.save(b);
+    DB.save(b);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     OtoAone a2 = new OtoAone("a4", "a test");
     b.setAone(a2);
-    Ebean.save(b);
+    DB.save(b);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(5);
     assertSql(sql.get(0)).contains("insert into oto_aone");
     assertSqlBind(sql.get(1));
@@ -89,9 +89,9 @@ public class TestOneToOneOrphanStringId extends BaseTestCase {
     assertThat(sql.get(3)).contains("delete from oto_aone where id=?");
     assertSqlBind(sql.get(4));
 
-    Ebean.delete(b);
+    DB.delete(b);
 
-    List<String> deletes = LoggedSqlCollector.stop();
+    List<String> deletes = LoggedSql.stop();
     assertThat(deletes).hasSize(2);
     assertThat(deletes.get(0)).contains("delete from oto_atwo");
     assertThat(deletes.get(1)).contains("delete from oto_aone");
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoin.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoin.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoin.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoin.java
index 0265b1c14..6662c5033 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoin.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoin.java
@@ -1,10 +1,10 @@
 package org.tests.model.onetoone;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -16,7 +16,7 @@ public class TestOneToOnePrimaryKeyJoin extends BaseTestCase {
     OtoPrime prime = new OtoPrime("p" + desc);
     OtoPrimeExtra extra = new OtoPrimeExtra("e" + desc);
     prime.setExtra(extra);
-    Ebean.save(prime);
+    DB.save(prime);
     return prime;
   }
 
@@ -29,7 +29,7 @@ public class TestOneToOnePrimaryKeyJoin extends BaseTestCase {
     assertThat(p1.getExtra().getEid()).isEqualTo(p1.getPid()).as("Same id values");
 
 
-    Query<OtoPrime> query = Ebean.find(OtoPrime.class).setId(p1.getPid());
+    Query<OtoPrime> query = DB.find(OtoPrime.class).setId(p1.getPid());
 
     OtoPrime found = query.findOne();
 
@@ -39,7 +39,7 @@ public class TestOneToOnePrimaryKeyJoin extends BaseTestCase {
 
     assertThat(found.getName()).isEqualTo("p" + desc);
 
-    Query<OtoPrime> queryWithFetch = Ebean.find(OtoPrime.class)
+    Query<OtoPrime> queryWithFetch = DB.find(OtoPrime.class)
       .setId(p1.getPid())
       .fetch("extra");
 
@@ -60,22 +60,22 @@ public class TestOneToOnePrimaryKeyJoin extends BaseTestCase {
     OtoPrimeExtra extra = oneWith.getExtra();
     extra.setExtra("modified");
 
-    Ebean.save(oneWith);
+    DB.save(oneWith);
 
     extra.setExtra("mod2");
     oneWith.setName("mod2");
 
-    Ebean.save(oneWith);
+    DB.save(oneWith);
   }
 
   private void thenDelete(OtoPrime found) {
 
-    OtoPrime bean = Ebean.find(OtoPrime.class, found.getPid());
+    OtoPrime bean = DB.find(OtoPrime.class, found.getPid());
 
-    LoggedSqlCollector.start();
-    Ebean.delete(bean);
+    LoggedSql.start();
+    DB.delete(bean);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from oto_prime_extra where");
     assertSql(sql.get(1)).contains("delete from oto_prime where");
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinBidi.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinBidi.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinBidi.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinBidi.java
index 6f5921435..b010f5b4b 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinBidi.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinBidi.java
@@ -1,10 +1,10 @@
 package org.tests.model.onetoone;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -16,7 +16,7 @@ public class TestOneToOnePrimaryKeyJoinBidi extends BaseTestCase {
     OtoUBPrime prime = new OtoUBPrime("u" + desc);
     OtoUBPrimeExtra extra = new OtoUBPrimeExtra("v" + desc);
     prime.setExtra(extra);
-    Ebean.save(prime);
+    DB.save(prime);
     return prime;
   }
 
@@ -28,7 +28,7 @@ public class TestOneToOnePrimaryKeyJoinBidi extends BaseTestCase {
 
     assertThat(p1.getExtra().getEid()).isEqualTo(p1.getPid()).as("Same id values");
 
-    Query<OtoUBPrime> query = Ebean.find(OtoUBPrime.class).setId(p1.getPid());
+    Query<OtoUBPrime> query = DB.find(OtoUBPrime.class).setId(p1.getPid());
 
     OtoUBPrime found = query.findOne();
 
@@ -38,7 +38,7 @@ public class TestOneToOnePrimaryKeyJoinBidi extends BaseTestCase {
 
     assertThat(found.getName()).isEqualTo("u" + desc);
 
-    Query<OtoUBPrime> queryWithFetch = Ebean.find(OtoUBPrime.class)
+    Query<OtoUBPrime> queryWithFetch = DB.find(OtoUBPrime.class)
       .setId(p1.getPid())
       .fetch("extra");
 
@@ -59,22 +59,22 @@ public class TestOneToOnePrimaryKeyJoinBidi extends BaseTestCase {
     OtoUBPrimeExtra extra = oneWith.getExtra();
     extra.setExtra("modified");
 
-    Ebean.save(oneWith);
+    DB.save(oneWith);
 
     extra.setExtra("mod2");
     oneWith.setName("mod2");
 
-    Ebean.save(oneWith);
+    DB.save(oneWith);
   }
 
   private void thenDelete(OtoUBPrime found) {
 
-    OtoUBPrime bean = Ebean.find(OtoUBPrime.class, found.getPid());
+    OtoUBPrime bean = DB.find(OtoUBPrime.class, found.getPid());
 
-    LoggedSqlCollector.start();
-    Ebean.delete(bean);
+    LoggedSql.start();
+    DB.delete(bean);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from oto_ubprime_extra where");
     assertSql(sql.get(1)).contains("delete from oto_ubprime where");
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinOptional.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinOptional.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinOptional.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinOptional.java
index 173bb87b8..0ea4c16d1 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinOptional.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOnePrimaryKeyJoinOptional.java
@@ -1,10 +1,10 @@
 package org.tests.model.onetoone;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -17,7 +17,7 @@ public class TestOneToOnePrimaryKeyJoinOptional extends BaseTestCase {
     OtoUPrime prime = new OtoUPrime("u" + desc);
     OtoUPrimeExtra extra = new OtoUPrimeExtra("v" + desc);
     prime.setExtra(extra);
-    Ebean.save(prime);
+    DB.save(prime);
     return prime;
   }
 
@@ -26,9 +26,9 @@ public class TestOneToOnePrimaryKeyJoinOptional extends BaseTestCase {
 
     String desc = "" + System.currentTimeMillis();
     OtoUPrime p1 = new OtoUPrime("u" + desc);
-    Ebean.save(p1);
+    DB.save(p1);
 
-    Query<OtoUPrime> query = Ebean.find(OtoUPrime.class)
+    Query<OtoUPrime> query = DB.find(OtoUPrime.class)
       .setId(p1.getPid())
       .fetch("extra", "eid");
 
@@ -49,7 +49,7 @@ public class TestOneToOnePrimaryKeyJoinOptional extends BaseTestCase {
     assertThat(p1.getExtra().getEid()).isEqualTo(p1.getPid()).as("Same id values");
 
 
-    Query<OtoUPrime> query = Ebean.find(OtoUPrime.class).setId(p1.getPid());
+    Query<OtoUPrime> query = DB.find(OtoUPrime.class).setId(p1.getPid());
 
     OtoUPrime found = query.findOne();
 
@@ -59,7 +59,7 @@ public class TestOneToOnePrimaryKeyJoinOptional extends BaseTestCase {
 
     assertThat(found.getName()).isEqualTo("u" + desc);
 
-    Query<OtoUPrime> queryWithFetch = Ebean.find(OtoUPrime.class)
+    Query<OtoUPrime> queryWithFetch = DB.find(OtoUPrime.class)
       .setId(p1.getPid())
       .fetch("extra");
 
@@ -81,23 +81,23 @@ public class TestOneToOnePrimaryKeyJoinOptional extends BaseTestCase {
     OtoUPrimeExtra extra = oneWith.getExtra();
     extra.setExtra("modified");
 
-    Ebean.save(oneWith);
+    DB.save(oneWith);
 
     extra.setExtra("mod2");
     oneWith.setName("mod2");
 
-    Ebean.save(oneWith);
+    DB.save(oneWith);
   }
 
   private void thenDelete(OtoUPrime found) {
 
 
-    OtoUPrime bean = Ebean.find(OtoUPrime.class, found.getPid());
+    OtoUPrime bean = DB.find(OtoUPrime.class, found.getPid());
 
-    LoggedSqlCollector.start();
-    Ebean.delete(bean);
+    LoggedSql.start();
+    DB.delete(bean);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from oto_uprime_extra where");
     assertSql(sql.get(1)).contains("delete from oto_uprime where");
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneSoftDeleteChild.java b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneSoftDeleteChild.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneSoftDeleteChild.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneSoftDeleteChild.java
index 326f822dc..d19da3abc 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/TestOneToOneSoftDeleteChild.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/TestOneToOneSoftDeleteChild.java
@@ -1,8 +1,8 @@
 package org.tests.model.onetoone;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -16,12 +16,12 @@ public class TestOneToOneSoftDeleteChild extends BaseTestCase {
     OtoSdMaster master = new OtoSdMaster("m1");
     master.setChild(child);
 
-    Ebean.save(master);
+    DB.save(master);
 
 
     verifyBeforeDelete(master, child);
 
-    Ebean.delete(child);
+    DB.delete(child);
 
     verifyAfterDelete(master, child);
   }
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/User.java b/ebean-test/src/test/java/org/tests/model/onetoone/User.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/User.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/User.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/album/Album.java b/ebean-test/src/test/java/org/tests/model/onetoone/album/Album.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/album/Album.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/album/Album.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/album/BaseModel.java b/ebean-test/src/test/java/org/tests/model/onetoone/album/BaseModel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/album/BaseModel.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/album/BaseModel.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/album/Cover.java b/ebean-test/src/test/java/org/tests/model/onetoone/album/Cover.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/album/Cover.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/album/Cover.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/album/DeleteById_SoftDelete_Tests.java b/ebean-test/src/test/java/org/tests/model/onetoone/album/DeleteById_SoftDelete_Tests.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/onetoone/album/DeleteById_SoftDelete_Tests.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/album/DeleteById_SoftDelete_Tests.java
index ddadfe530..c4612e613 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/album/DeleteById_SoftDelete_Tests.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/album/DeleteById_SoftDelete_Tests.java
@@ -3,15 +3,15 @@ package org.tests.model.onetoone.album;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Transaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class DeleteById_SoftDelete_Tests extends BaseTestCase {
 
@@ -21,11 +21,11 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     Cover cover = new Cover("a1");
     cover.save();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.delete(Cover.class, cover.getId());
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isPlatformBooleanNative()) {
       assertSql(sql.get(0)).contains("update cover set deleted=true where id = ?");
@@ -54,11 +54,11 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
 
     cover1.setDeleted(false);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     cover1.update();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("update cover set deleted=? where id=?; -- bind(false");
 
@@ -74,11 +74,11 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     Cover cover = new Cover("a1");
     cover.save();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.getDefault().delete(Cover.class, cover.getId(), null);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isPlatformBooleanNative()) {
       assertSql(sql.get(0)).contains("update cover set deleted=true where id = ?");
@@ -94,11 +94,11 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     Cover cover = new Cover("a2");
     cover.save();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.getDefault().deletePermanent(Cover.class, cover.getId(), null);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("delete from cover where id = ?");
   }
@@ -109,11 +109,11 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     List<Cover> beans = beans(2);
     DB.saveAll(beans);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.deleteAll(Cover.class, ids(beans));
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isPlatformBooleanNative()) {
       assertSql(sql.get(0)).contains("update cover set deleted=true where id ");
@@ -128,14 +128,14 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     List<Cover> beans = beans(2);
     DB.saveAll(beans);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     try (Transaction transaction = DB.beginTransaction()) {
       DB.getDefault().deleteAll(Cover.class, ids(beans), transaction);
       transaction.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     if (isPlatformBooleanNative()) {
       assertSql(sql.get(0)).contains("update cover set deleted=true where id");
@@ -150,11 +150,11 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     List<Cover> beans = beans(2);
     DB.saveAll(beans);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.deleteAllPermanent(Cover.class, ids(beans));
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     platformAssertIn(sql.get(0), "delete from cover where id ");
   }
@@ -165,11 +165,11 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     List<Cover> beans = beans(2);
     DB.saveAll(beans);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.deleteAllPermanent(Cover.class, ids(beans));
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     platformAssertIn(sql.get(0), "delete from cover where id ");
   }
@@ -181,14 +181,14 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     List<Cover> beans = beans(2);
     DB.saveAll(beans);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     try (Transaction transaction = DB.beginTransaction()) {
       DB.getDefault().deleteAllPermanent(Cover.class, ids(beans), transaction);
       transaction.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     platformAssertIn(sql.get(0), "delete from cover where id ");
   }
@@ -199,11 +199,11 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     List<Cover> beans = beans(2);
     DB.saveAll(beans);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.deleteAll(beans);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     if (isPersistBatchOnCascade()) {
       assertSql(sql.get(0)).contains("update cover set deleted=? where id=?");
@@ -218,11 +218,11 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     List<Cover> beans = beans(2);
     DB.saveAll(beans);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.deleteAll(beans);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     if (isPersistBatchOnCascade()) {
       assertSql(sql.get(0)).contains("update cover set deleted=? where id=?");
@@ -238,14 +238,14 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     List<Cover> beans = beans(2);
     DB.saveAll(beans);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     try (Transaction transaction = DB.beginTransaction()) {
       DB.getDefault().deleteAll(beans, transaction);
       transaction.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     if (isPersistBatchOnCascade()) {
       assertSql(sql.get(0)).contains("update cover set deleted=? where id=?");
@@ -261,11 +261,11 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     List<Cover> beans = beans(2);
     DB.saveAll(beans);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.deleteAllPermanent(beans);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("delete from cover where id=?");
   }
@@ -276,14 +276,14 @@ public class DeleteById_SoftDelete_Tests extends BaseTestCase {
     List<Cover> beans = beans(2);
     DB.saveAll(beans);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     try (Transaction transaction = DB.beginTransaction()) {
       DB.getDefault().deleteAllPermanent(beans, transaction);
       transaction.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("delete from cover where id=?");
   }
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/album/TestOneToOneHardDelete.java b/ebean-test/src/test/java/org/tests/model/onetoone/album/TestOneToOneHardDelete.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/onetoone/album/TestOneToOneHardDelete.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/album/TestOneToOneHardDelete.java
index 41011c84b..98c4acbe7 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/album/TestOneToOneHardDelete.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/album/TestOneToOneHardDelete.java
@@ -2,8 +2,8 @@ package org.tests.model.onetoone.album;
 
 
 import io.ebean.BaseTestCase;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -25,14 +25,14 @@ public class TestOneToOneHardDelete extends BaseTestCase {
 
     Album found1 = Album.find.byId(album.getId());
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // ---------------------
     // SOFT DELETE
     // ---------------------
     found1.delete();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     // assert we loaded the missing/unloaded foreign key
     assertThat(trimSql(sql.get(0), 1)).contains("select t0.id, t0.cover_id from album t0 where t0.id = ?");
@@ -42,14 +42,14 @@ public class TestOneToOneHardDelete extends BaseTestCase {
 
     Album found2 = Album.find.query().setId(album.getId()).setIncludeSoftDeletes().findOne();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // ---------------------
     // HARD DELETE
     // ---------------------
     found2.deletePermanent();
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     // assert we loaded the missing/unloaded foreign key
     assertThat(trimSql(sql.get(0), 1)).contains("select t0.id, t0.cover_id from album t0 where t0.id = ?");
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/calcd/CalcDData.java b/ebean-test/src/test/java/org/tests/model/onetoone/calcd/CalcDData.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/calcd/CalcDData.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/calcd/CalcDData.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/calcd/CalcDInput.java b/ebean-test/src/test/java/org/tests/model/onetoone/calcd/CalcDInput.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/onetoone/calcd/CalcDInput.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/calcd/CalcDInput.java
diff --git a/ebean-core/src/test/java/org/tests/model/onetoone/calcd/TestOneToOnePrimaryKeyJoinMapping.java b/ebean-test/src/test/java/org/tests/model/onetoone/calcd/TestOneToOnePrimaryKeyJoinMapping.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/model/onetoone/calcd/TestOneToOnePrimaryKeyJoinMapping.java
rename to ebean-test/src/test/java/org/tests/model/onetoone/calcd/TestOneToOnePrimaryKeyJoinMapping.java
index 9e1aa68f0..e115543ee 100644
--- a/ebean-core/src/test/java/org/tests/model/onetoone/calcd/TestOneToOnePrimaryKeyJoinMapping.java
+++ b/ebean-test/src/test/java/org/tests/model/onetoone/calcd/TestOneToOnePrimaryKeyJoinMapping.java
@@ -1,7 +1,7 @@
 package org.tests.model.onetoone.calcd;
 
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/model/orderentity/OrderEntity.java b/ebean-test/src/test/java/org/tests/model/orderentity/OrderEntity.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/model/orderentity/OrderEntity.java
rename to ebean-test/src/test/java/org/tests/model/orderentity/OrderEntity.java
index 2a1e032dc..d131ed6d8 100644
--- a/ebean-core/src/test/java/org/tests/model/orderentity/OrderEntity.java
+++ b/ebean-test/src/test/java/org/tests/model/orderentity/OrderEntity.java
@@ -1,14 +1,7 @@
 package org.tests.model.orderentity;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
-
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/orderentity/OrderItemEntity.java b/ebean-test/src/test/java/org/tests/model/orderentity/OrderItemEntity.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/orderentity/OrderItemEntity.java
rename to ebean-test/src/test/java/org/tests/model/orderentity/OrderItemEntity.java
index d1d40961c..eb8543c64 100644
--- a/ebean-core/src/test/java/org/tests/model/orderentity/OrderItemEntity.java
+++ b/ebean-test/src/test/java/org/tests/model/orderentity/OrderItemEntity.java
@@ -1,13 +1,7 @@
 package org.tests.model.orderentity;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
-
 import java.math.BigDecimal;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/orphanremoval/OmBeanListChild.java b/ebean-test/src/test/java/org/tests/model/orphanremoval/OmBeanListChild.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/orphanremoval/OmBeanListChild.java
rename to ebean-test/src/test/java/org/tests/model/orphanremoval/OmBeanListChild.java
diff --git a/ebean-core/src/test/java/org/tests/model/orphanremoval/OmBeanListParent.java b/ebean-test/src/test/java/org/tests/model/orphanremoval/OmBeanListParent.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/orphanremoval/OmBeanListParent.java
rename to ebean-test/src/test/java/org/tests/model/orphanremoval/OmBeanListParent.java
diff --git a/ebean-core/src/test/java/org/tests/model/orphanremoval/OrpDetail.java b/ebean-test/src/test/java/org/tests/model/orphanremoval/OrpDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/orphanremoval/OrpDetail.java
rename to ebean-test/src/test/java/org/tests/model/orphanremoval/OrpDetail.java
diff --git a/ebean-core/src/test/java/org/tests/model/orphanremoval/OrpDetail2.java b/ebean-test/src/test/java/org/tests/model/orphanremoval/OrpDetail2.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/orphanremoval/OrpDetail2.java
rename to ebean-test/src/test/java/org/tests/model/orphanremoval/OrpDetail2.java
diff --git a/ebean-core/src/test/java/org/tests/model/orphanremoval/OrpMaster.java b/ebean-test/src/test/java/org/tests/model/orphanremoval/OrpMaster.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/orphanremoval/OrpMaster.java
rename to ebean-test/src/test/java/org/tests/model/orphanremoval/OrpMaster.java
index cd443a84c..96384d261 100644
--- a/ebean-core/src/test/java/org/tests/model/orphanremoval/OrpMaster.java
+++ b/ebean-test/src/test/java/org/tests/model/orphanremoval/OrpMaster.java
@@ -2,13 +2,8 @@ package org.tests.model.orphanremoval;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
-
 import java.util.List;
 
 @Cache
diff --git a/ebean-core/src/test/java/org/tests/model/orphanremoval/OrpMaster2.java b/ebean-test/src/test/java/org/tests/model/orphanremoval/OrpMaster2.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/orphanremoval/OrpMaster2.java
rename to ebean-test/src/test/java/org/tests/model/orphanremoval/OrpMaster2.java
index 09338bdda..9565a6a42 100644
--- a/ebean-core/src/test/java/org/tests/model/orphanremoval/OrpMaster2.java
+++ b/ebean-test/src/test/java/org/tests/model/orphanremoval/OrpMaster2.java
@@ -2,13 +2,8 @@ package org.tests.model.orphanremoval;
 
 import io.ebean.annotation.Cache;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
-
 import java.util.List;
 
 @Cache
diff --git a/ebean-core/src/test/java/org/tests/model/orphanremoval/TestOrphanRemovalOverwrite.java b/ebean-test/src/test/java/org/tests/model/orphanremoval/TestOrphanRemovalOverwrite.java
similarity index 62%
rename from ebean-core/src/test/java/org/tests/model/orphanremoval/TestOrphanRemovalOverwrite.java
rename to ebean-test/src/test/java/org/tests/model/orphanremoval/TestOrphanRemovalOverwrite.java
index 9c6fa045b..446fff4b2 100644
--- a/ebean-core/src/test/java/org/tests/model/orphanremoval/TestOrphanRemovalOverwrite.java
+++ b/ebean-test/src/test/java/org/tests/model/orphanremoval/TestOrphanRemovalOverwrite.java
@@ -1,12 +1,12 @@
 package org.tests.model.orphanremoval;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
 import static java.util.Collections.singletonList;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestOrphanRemovalOverwrite {
 
@@ -29,9 +29,8 @@ public class TestOrphanRemovalOverwrite {
     // Refreshing here generates new objects for the associated children that are referred to by the parent.
     parent.refresh();
 
-    assertNotNull("The children should now have Ids as they are persisted to the db.", childList.get(0).getId());
-    assertEquals("The children should have the same Id as the ones on the parent.",
-      childList.get(0).getId(), parent.getChildren().get(0).getId());
-    assertEquals("The children should therefore equal the children on the parent.", childList, parent.getChildren());
+    assertNotNull(childList.get(0).getId());
+    assertEquals(childList.get(0).getId(), parent.getChildren().get(0).getId());
+    assertEquals(childList, parent.getChildren());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2M.java b/ebean-test/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2M.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2M.java
rename to ebean-test/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2M.java
index 0148979fa..d888f0c62 100644
--- a/ebean-core/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2M.java
+++ b/ebean-test/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2M.java
@@ -1,9 +1,9 @@
 package org.tests.model.orphanremoval;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -18,17 +18,17 @@ public class TestOrphanRemoveO2M extends BaseTestCase {
     master.getDetails().add(new OrpDetail("d1", "d1"));
     master.getDetails().add(new OrpDetail("d2", "d2"));
 
-    Ebean.save(master);
+    DB.save(master);
 
     master.getDetails().clear();
 
-    LoggedSqlCollector.start();
-    Ebean.save(master);
+    LoggedSql.start();
+    DB.save(master);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
-    assertThat(Ebean.find(OrpDetail.class, "d1")).isNull();
-    assertThat(Ebean.find(OrpDetail.class, "d2")).isNull();
+    assertThat(DB.find(OrpDetail.class, "d1")).isNull();
+    assertThat(DB.find(OrpDetail.class, "d2")).isNull();
 
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("delete from orp_detail where id=?");
@@ -43,16 +43,16 @@ public class TestOrphanRemoveO2M extends BaseTestCase {
     m0.getDetails().add(new OrpDetail("d21", "d1"));
     m0.getDetails().add(new OrpDetail("d22", "d2"));
 
-    Ebean.save(m0);
+    DB.save(m0);
 
-    OrpMaster m1 = Ebean.find(OrpMaster.class, "m2");
+    OrpMaster m1 = DB.find(OrpMaster.class, "m2");
     m1.getDetails().size();
 
     m1.getDetails().clear();
     m1.getDetails().add(new OrpDetail("d23", "d3"));
-    Ebean.save(m1);
+    DB.save(m1);
 
-    m1 = Ebean.find(OrpMaster.class, "m2");
+    m1 = DB.find(OrpMaster.class, "m2");
     // Expect only one.
     assertThat(m1.getDetails()).hasSize(1);
     assertThat(m1.getDetails()).extracting("id").containsExactly("d23");
@@ -60,14 +60,14 @@ public class TestOrphanRemoveO2M extends BaseTestCase {
     m1.getDetails().clear();
     m1.getDetails().add(new OrpDetail("d24", "d4"));
     m1.getDetails().add(new OrpDetail("d25", "d5"));
-    Ebean.save(m1);
+    DB.save(m1);
 
-    m1 = Ebean.find(OrpMaster.class, "m2");
+    m1 = DB.find(OrpMaster.class, "m2");
     assertThat(m1.getDetails()).hasSize(2);
     assertThat(m1.getDetails()).extracting("id").contains("d24", "d25");
 
 
-    m1 = Ebean.find(OrpMaster.class)
+    m1 = DB.find(OrpMaster.class)
       .setId("m2")
       .setUseCache(false)
       .findOne();
diff --git a/ebean-core/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2MFlat.java b/ebean-test/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2MFlat.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2MFlat.java
rename to ebean-test/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2MFlat.java
index 74c1c5fc1..cce4380c9 100644
--- a/ebean-core/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2MFlat.java
+++ b/ebean-test/src/test/java/org/tests/model/orphanremoval/TestOrphanRemoveO2MFlat.java
@@ -1,8 +1,8 @@
 package org.tests.model.orphanremoval;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -16,16 +16,16 @@ public class TestOrphanRemoveO2MFlat extends BaseTestCase {
     m0.getDetails().add(new OrpDetail2("d21", "d1", "m2"));
     m0.getDetails().add(new OrpDetail2("d22", "d2", "m2"));
 
-    Ebean.save(m0);
+    DB.save(m0);
 
-    OrpMaster2 m1 = Ebean.find(OrpMaster2.class, "m2");
+    OrpMaster2 m1 = DB.find(OrpMaster2.class, "m2");
     m1.getDetails().size();
 
     m1.getDetails().clear();
     m1.getDetails().add(new OrpDetail2("d23", "d3", "m2"));
-    Ebean.save(m1);
+    DB.save(m1);
 
-    m1 = Ebean.find(OrpMaster2.class, "m2");
+    m1 = DB.find(OrpMaster2.class, "m2");
     // Expect only one.
     assertThat(m1.getDetails()).hasSize(1);
     assertThat(m1.getDetails()).extracting("id").contains("d23");
@@ -33,14 +33,14 @@ public class TestOrphanRemoveO2MFlat extends BaseTestCase {
     m1.getDetails().clear();
     m1.getDetails().add(new OrpDetail2("d24", "d4", "m2"));
     m1.getDetails().add(new OrpDetail2("d25", "d5", "m2"));
-    Ebean.save(m1);
+    DB.save(m1);
 
-    m1 = Ebean.find(OrpMaster2.class, "m2");
+    m1 = DB.find(OrpMaster2.class, "m2");
     assertThat(m1.getDetails()).hasSize(2);
     assertThat(m1.getDetails()).extracting("id").contains("d24", "d25");
 
 
-    m1 = Ebean.find(OrpMaster2.class)
+    m1 = DB.find(OrpMaster2.class)
       .setId("m2")
       .setUseCache(false)
       .findOne();
diff --git a/ebean-core/src/test/java/org/tests/model/prnt/MPrinter.java b/ebean-test/src/test/java/org/tests/model/prnt/MPrinter.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/model/prnt/MPrinter.java
rename to ebean-test/src/test/java/org/tests/model/prnt/MPrinter.java
index 76c229d92..de541ec3c 100644
--- a/ebean-core/src/test/java/org/tests/model/prnt/MPrinter.java
+++ b/ebean-test/src/test/java/org/tests/model/prnt/MPrinter.java
@@ -1,12 +1,6 @@
 package org.tests.model.prnt;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class MPrinter {
diff --git a/ebean-core/src/test/java/org/tests/model/prnt/MPrinterListener.java b/ebean-test/src/test/java/org/tests/model/prnt/MPrinterListener.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/prnt/MPrinterListener.java
rename to ebean-test/src/test/java/org/tests/model/prnt/MPrinterListener.java
index a658f7cf1..01ceb7972 100644
--- a/ebean-core/src/test/java/org/tests/model/prnt/MPrinterListener.java
+++ b/ebean-test/src/test/java/org/tests/model/prnt/MPrinterListener.java
@@ -18,8 +18,8 @@ public class MPrinterListener extends BeanPersistAdapter {
   public boolean preUpdate(BeanPersistRequest<?> request) {
 
     logger.info("preUpdate ...");
-    logger.info("preUpdate ..." + request.getUpdatedValues());
-    request.getUpdatedProperties();
+    logger.info("preUpdate ..." + request.updatedValues());
+    request.updatedProperties();
     return super.preUpdate(request);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/prnt/MPrinterState.java b/ebean-test/src/test/java/org/tests/model/prnt/MPrinterState.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/model/prnt/MPrinterState.java
rename to ebean-test/src/test/java/org/tests/model/prnt/MPrinterState.java
index 9d6657043..3bef094f5 100644
--- a/ebean-core/src/test/java/org/tests/model/prnt/MPrinterState.java
+++ b/ebean-test/src/test/java/org/tests/model/prnt/MPrinterState.java
@@ -1,11 +1,6 @@
 package org.tests.model.prnt;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class MPrinterState {
diff --git a/ebean-core/src/test/java/org/tests/model/prnt/MSomeOther.java b/ebean-test/src/test/java/org/tests/model/prnt/MSomeOther.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/prnt/MSomeOther.java
rename to ebean-test/src/test/java/org/tests/model/prnt/MSomeOther.java
diff --git a/ebean-core/src/test/java/org/tests/model/prnt/TestPrinterStateIssue.java b/ebean-test/src/test/java/org/tests/model/prnt/TestPrinterStateIssue.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/model/prnt/TestPrinterStateIssue.java
rename to ebean-test/src/test/java/org/tests/model/prnt/TestPrinterStateIssue.java
index afdcfb78a..0ad676aa6 100644
--- a/ebean-core/src/test/java/org/tests/model/prnt/TestPrinterStateIssue.java
+++ b/ebean-test/src/test/java/org/tests/model/prnt/TestPrinterStateIssue.java
@@ -1,8 +1,8 @@
 package org.tests.model.prnt;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 public class TestPrinterStateIssue extends BaseTestCase {
 
@@ -11,42 +11,42 @@ public class TestPrinterStateIssue extends BaseTestCase {
 
     MSomeOther other = new MSomeOther();
     other.setName("otherRefBean");
-    Ebean.save(other);
+    DB.save(other);
 
     MPrinter printer = new MPrinter();
     printer.setDataWarehouseId(other);
     printer.setName("foo");
     printer.setAllFlags(20L);
 
-    Ebean.save(printer);
+    DB.save(printer);
 
     MPrinterState state = new MPrinterState();
     state.setDataWarehouseId(other);
     state.setFlags(10L);
     state.setPrinter(printer);
-    Ebean.save(state);
+    DB.save(state);
 
     MPrinterState cyanState = new MPrinterState();
     cyanState.setDataWarehouseId(other);
     cyanState.setFlags(10L);
     cyanState.setPrinter(printer);
-    Ebean.save(state);
+    DB.save(state);
 
     printer.setCurrentState(state);
     printer.setLastTonerSwapCyan(cyanState);
-    Ebean.save(printer);
+    DB.save(printer);
 
     MPrinterState newState = new MPrinterState();
     newState.setDataWarehouseId(other);
     newState.setFlags(10L);
-    //Ebean.save(newState);
+    //DB.save(newState);
 
     printer.setLastTonerSwapCyan(newState);
     newState.setPrinter(printer);
 
-    Ebean.save(printer);
+    DB.save(printer);
 
-    MPrinter printer1 = Ebean.find(MPrinter.class, printer.getId());
+    MPrinter printer1 = DB.find(MPrinter.class, printer.getId());
     MPrinterState state1 = printer1.getCurrentState();
     state1.setFlags(9L);
     printer1.setAllFlags(99L);
@@ -54,11 +54,11 @@ public class TestPrinterStateIssue extends BaseTestCase {
     state1.setFlags(7L);
 
 
-//    BeanState beanState = Ebean.getBeanState(printer1);
+//    BeanState beanState = DB.beanState(printer1);
 //    Set<String> changedProps = beanState.getChangedProps();
 //    System.out.println("changed: "+changedProps);
 
-    Ebean.save(printer1);
+    DB.save(printer1);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/model/pview/Paggview.java b/ebean-test/src/test/java/org/tests/model/pview/Paggview.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/pview/Paggview.java
rename to ebean-test/src/test/java/org/tests/model/pview/Paggview.java
diff --git a/ebean-core/src/test/java/org/tests/model/pview/Pview.java b/ebean-test/src/test/java/org/tests/model/pview/Pview.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/model/pview/Pview.java
rename to ebean-test/src/test/java/org/tests/model/pview/Pview.java
index e3445c396..a985fb76c 100644
--- a/ebean-core/src/test/java/org/tests/model/pview/Pview.java
+++ b/ebean-test/src/test/java/org/tests/model/pview/Pview.java
@@ -1,15 +1,6 @@
 package org.tests.model.pview;
 
-import javax.persistence.Basic;
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.List;
 import java.util.UUID;
 
diff --git a/ebean-core/src/test/java/org/tests/model/pview/TestPview.java b/ebean-test/src/test/java/org/tests/model/pview/TestPview.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/model/pview/TestPview.java
rename to ebean-test/src/test/java/org/tests/model/pview/TestPview.java
index d1de56f0d..72d885173 100644
--- a/ebean-core/src/test/java/org/tests/model/pview/TestPview.java
+++ b/ebean-test/src/test/java/org/tests/model/pview/TestPview.java
@@ -1,9 +1,9 @@
 package org.tests.model.pview;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.UUID;
 
@@ -14,9 +14,9 @@ public class TestPview extends BaseTestCase {
   @Test
   public void test() {
 
-    Wview wview = Ebean.getReference(Wview.class, UUID.randomUUID());
+    Wview wview = DB.reference(Wview.class, UUID.randomUUID());
 
-    Query<Paggview> query = Ebean.find(Paggview.class);
+    Query<Paggview> query = DB.find(Paggview.class);
     query.select("amount");
     query.where().eq("pview.wviews", wview);
     query.order("pview.value");
diff --git a/ebean-core/src/test/java/org/tests/model/pview/Wview.java b/ebean-test/src/test/java/org/tests/model/pview/Wview.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/model/pview/Wview.java
rename to ebean-test/src/test/java/org/tests/model/pview/Wview.java
index 364b73bf0..10f8b6237 100644
--- a/ebean-core/src/test/java/org/tests/model/pview/Wview.java
+++ b/ebean-test/src/test/java/org/tests/model/pview/Wview.java
@@ -1,12 +1,7 @@
 package org.tests.model.pview;
 
-import javax.persistence.Basic;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Table;
+import javax.persistence.*;
 import javax.validation.constraints.Size;
-
 import java.util.UUID;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/rawsql/ERawSqlAggBean.java b/ebean-test/src/test/java/org/tests/model/rawsql/ERawSqlAggBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/rawsql/ERawSqlAggBean.java
rename to ebean-test/src/test/java/org/tests/model/rawsql/ERawSqlAggBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/selfref/BaseResourceFile.java b/ebean-test/src/test/java/org/tests/model/selfref/BaseResourceFile.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/model/selfref/BaseResourceFile.java
rename to ebean-test/src/test/java/org/tests/model/selfref/BaseResourceFile.java
index fa96461c1..80cbd64c8 100644
--- a/ebean-core/src/test/java/org/tests/model/selfref/BaseResourceFile.java
+++ b/ebean-test/src/test/java/org/tests/model/selfref/BaseResourceFile.java
@@ -3,7 +3,6 @@ package org.tests.model.selfref;
 import javax.persistence.Column;
 import javax.persistence.Id;
 import javax.persistence.MappedSuperclass;
-
 import java.io.Serializable;
 import java.util.UUID;
 
diff --git a/ebean-core/src/test/java/org/tests/model/selfref/ResourceFile.java b/ebean-test/src/test/java/org/tests/model/selfref/ResourceFile.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/model/selfref/ResourceFile.java
rename to ebean-test/src/test/java/org/tests/model/selfref/ResourceFile.java
index 3be5e7674..2efff0071 100644
--- a/ebean-core/src/test/java/org/tests/model/selfref/ResourceFile.java
+++ b/ebean-test/src/test/java/org/tests/model/selfref/ResourceFile.java
@@ -1,13 +1,6 @@
 package org.tests.model.selfref;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.HashSet;
 import java.util.Set;
 
diff --git a/ebean-core/src/test/java/org/tests/model/selfref/SelfParent.java b/ebean-test/src/test/java/org/tests/model/selfref/SelfParent.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/selfref/SelfParent.java
rename to ebean-test/src/test/java/org/tests/model/selfref/SelfParent.java
index 0e94da293..7999dcb80 100644
--- a/ebean-core/src/test/java/org/tests/model/selfref/SelfParent.java
+++ b/ebean-test/src/test/java/org/tests/model/selfref/SelfParent.java
@@ -1,11 +1,6 @@
 package org.tests.model.selfref;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/selfref/SelfRefCustomer.java b/ebean-test/src/test/java/org/tests/model/selfref/SelfRefCustomer.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/model/selfref/SelfRefCustomer.java
rename to ebean-test/src/test/java/org/tests/model/selfref/SelfRefCustomer.java
index 73e7aab1c..f29430aed 100644
--- a/ebean-core/src/test/java/org/tests/model/selfref/SelfRefCustomer.java
+++ b/ebean-test/src/test/java/org/tests/model/selfref/SelfRefCustomer.java
@@ -1,10 +1,6 @@
 package org.tests.model.selfref;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "self_ref_customer")
diff --git a/ebean-core/src/test/java/org/tests/model/selfref/SelfRefExample.java b/ebean-test/src/test/java/org/tests/model/selfref/SelfRefExample.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/model/selfref/SelfRefExample.java
rename to ebean-test/src/test/java/org/tests/model/selfref/SelfRefExample.java
index 09a6ab1dc..2e054e5ad 100644
--- a/ebean-core/src/test/java/org/tests/model/selfref/SelfRefExample.java
+++ b/ebean-test/src/test/java/org/tests/model/selfref/SelfRefExample.java
@@ -1,11 +1,6 @@
 package org.tests.model.selfref;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderBy;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/selfref/TestResourceFileSelfRef.java b/ebean-test/src/test/java/org/tests/model/selfref/TestResourceFileSelfRef.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/selfref/TestResourceFileSelfRef.java
rename to ebean-test/src/test/java/org/tests/model/selfref/TestResourceFileSelfRef.java
index fbb2ee7ae..e7c3d42e5 100644
--- a/ebean-core/src/test/java/org/tests/model/selfref/TestResourceFileSelfRef.java
+++ b/ebean-test/src/test/java/org/tests/model/selfref/TestResourceFileSelfRef.java
@@ -1,16 +1,16 @@
 package org.tests.model.selfref;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
 
 public class TestResourceFileSelfRef extends BaseTestCase {
 
   @Test
   public void test() {
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     ResourceFile childFile1 = new ResourceFile();
     childFile1.setName("childFile1");
diff --git a/ebean-core/src/test/java/org/tests/model/selfref/TestSelfRefExample.java b/ebean-test/src/test/java/org/tests/model/selfref/TestSelfRefExample.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/selfref/TestSelfRefExample.java
rename to ebean-test/src/test/java/org/tests/model/selfref/TestSelfRefExample.java
index 65e00f683..f99d5d6de 100644
--- a/ebean-core/src/test/java/org/tests/model/selfref/TestSelfRefExample.java
+++ b/ebean-test/src/test/java/org/tests/model/selfref/TestSelfRefExample.java
@@ -1,15 +1,15 @@
 package org.tests.model.selfref;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import javax.persistence.PersistenceException;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestSelfRefExample extends BaseTestCase {
 
@@ -17,7 +17,7 @@ public class TestSelfRefExample extends BaseTestCase {
   public void test() {
 
     try {
-      Ebean.createSqlUpdate("delete from self_ref_example").execute();
+      DB.sqlUpdate("delete from self_ref_example").execute();
     } catch (PersistenceException e) {
       logger.debug("TestSelfRefExample skipped - MySql not deleting based on constraints");
       return;
@@ -32,16 +32,16 @@ public class TestSelfRefExample extends BaseTestCase {
     SelfRefExample e7 = new SelfRefExample("test3", e3);
     SelfRefExample e8 = new SelfRefExample("test3", e7);
 
-    Ebean.save(e1);
-    Ebean.save(e2);
-    Ebean.save(e3);
-    Ebean.save(e4);
-    Ebean.save(e5);
-    Ebean.save(e6);
-    Ebean.save(e7);
-    Ebean.save(e8);
+    DB.save(e1);
+    DB.save(e2);
+    DB.save(e3);
+    DB.save(e4);
+    DB.save(e5);
+    DB.save(e6);
+    DB.save(e7);
+    DB.save(e8);
 
-    Query<SelfRefExample> examples = Ebean.find(SelfRefExample.class).setLazyLoadBatchSize(1);
+    Query<SelfRefExample> examples = DB.find(SelfRefExample.class).setLazyLoadBatchSize(1);
     List<SelfRefExample> list = examples.where().eq("name", "test1").order().asc("id").findList();
 
     assertThat(list).hasSize(2);
@@ -66,7 +66,7 @@ public class TestSelfRefExample extends BaseTestCase {
     assertThat(e3Searched.getChildren()).extracting("id").contains(e7.getId());
 
     // If we get all the items, you can see the structure goes down a fair bit further.
-    Query<SelfRefExample> examples2 = Ebean.createQuery(SelfRefExample.class).order("id asc");
+    Query<SelfRefExample> examples2 = DB.createQuery(SelfRefExample.class).order("id asc");
     List<SelfRefExample> list2 = examples2.findList();
 
     assertEquals(e1.getId(), list2.get(0).getId());
diff --git a/ebean-core/src/test/java/org/tests/model/selfref/TestTextJsonSelfRef.java b/ebean-test/src/test/java/org/tests/model/selfref/TestTextJsonSelfRef.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/model/selfref/TestTextJsonSelfRef.java
rename to ebean-test/src/test/java/org/tests/model/selfref/TestTextJsonSelfRef.java
index 5163c9ffb..5715204c5 100644
--- a/ebean-core/src/test/java/org/tests/model/selfref/TestTextJsonSelfRef.java
+++ b/ebean-test/src/test/java/org/tests/model/selfref/TestTextJsonSelfRef.java
@@ -2,20 +2,21 @@ package org.tests.model.selfref;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
 public class TestTextJsonSelfRef extends BaseTestCase {
 
   @Test
   public void test() {
 
-    Ebean.execute(() -> {
+    DB.execute(() -> {
 
-      if (Ebean.find(SelfRefCustomer.class).findCount() == 0) {
+      if (DB.find(SelfRefCustomer.class).findCount() == 0) {
         SelfRefCustomer c1 = new SelfRefCustomer();
         c1.setName("Foo");
         c1.setReferredBy(c1);
@@ -28,22 +29,22 @@ public class TestTextJsonSelfRef extends BaseTestCase {
         c3.setName("baz");
         c3.setReferredBy(c1);
 
-        Ebean.save(c1);
-        Ebean.save(c2);
-        Ebean.save(c3);
+        DB.save(c1);
+        DB.save(c2);
+        DB.save(c3);
       }
     });
 
-    List<SelfRefCustomer> customers = Ebean.find(SelfRefCustomer.class).order("id desc").findList();
+    List<SelfRefCustomer> customers = DB.find(SelfRefCustomer.class).order("id desc").findList();
 
     // Check that there are no 'reference' beans here
     for (SelfRefCustomer cust : customers) {
-      BeanState beanState = Ebean.getBeanState(cust);
-      Assert.assertFalse(beanState.isReference());
+      BeanState beanState = DB.beanState(cust);
+      assertFalse(beanState.isReference());
     }
 
 //    JsonWriteOptions options = JsonWriteOptions.parsePath("(id,name,referredBy(id))");
-//    String customerContent = Ebean.createJsonContext().toJson(customers);//, false, options);
+//    String customerContent = DB.json().toJson(customers);//, false, options);
 //    System.out.println("Customers: " + customerContent);
 //
 //    Assert
diff --git a/ebean-core/src/test/java/org/tests/model/site/DataContainer.java b/ebean-test/src/test/java/org/tests/model/site/DataContainer.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/site/DataContainer.java
rename to ebean-test/src/test/java/org/tests/model/site/DataContainer.java
diff --git a/ebean-core/src/test/java/org/tests/model/site/Site.java b/ebean-test/src/test/java/org/tests/model/site/Site.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/site/Site.java
rename to ebean-test/src/test/java/org/tests/model/site/Site.java
index ce5c12594..1b950f821 100644
--- a/ebean-core/src/test/java/org/tests/model/site/Site.java
+++ b/ebean-test/src/test/java/org/tests/model/site/Site.java
@@ -2,12 +2,7 @@ package org.tests.model.site;
 
 import io.ebean.Model;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.OneToOne;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
diff --git a/ebean-core/src/test/java/org/tests/model/site/SiteAddress.java b/ebean-test/src/test/java/org/tests/model/site/SiteAddress.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/site/SiteAddress.java
rename to ebean-test/src/test/java/org/tests/model/site/SiteAddress.java
diff --git a/ebean-core/src/test/java/org/tests/model/site/TestTreeModel.java b/ebean-test/src/test/java/org/tests/model/site/TestTreeModel.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/site/TestTreeModel.java
rename to ebean-test/src/test/java/org/tests/model/site/TestTreeModel.java
index 54eb9b808..b133061c6 100644
--- a/ebean-core/src/test/java/org/tests/model/site/TestTreeModel.java
+++ b/ebean-test/src/test/java/org/tests/model/site/TestTreeModel.java
@@ -1,8 +1,8 @@
 package org.tests.model.site;
 
 import io.ebean.BaseTestCase;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -21,10 +21,10 @@ public class TestTreeModel extends BaseTestCase {
     grandparent.setChildren(singletonList(parent));
     parent.setChildren(singletonList(child));
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     grandparent.save();
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(5);
     assertSql(sql.get(0)).contains("insert into tree_entity");
     assertSql(sql.get(1)).contains("insert into tree_entity");
diff --git a/ebean-core/src/test/java/org/tests/model/site/TreeEntity.java b/ebean-test/src/test/java/org/tests/model/site/TreeEntity.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/site/TreeEntity.java
rename to ebean-test/src/test/java/org/tests/model/site/TreeEntity.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/BaseSoftDelete.java b/ebean-test/src/test/java/org/tests/model/softdelete/BaseSoftDelete.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/BaseSoftDelete.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/BaseSoftDelete.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/EBasicNoSDChild.java b/ebean-test/src/test/java/org/tests/model/softdelete/EBasicNoSDChild.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/EBasicNoSDChild.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/EBasicNoSDChild.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/EBasicSDChild.java b/ebean-test/src/test/java/org/tests/model/softdelete/EBasicSDChild.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/EBasicSDChild.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/EBasicSDChild.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/EBasicSoftDelete.java b/ebean-test/src/test/java/org/tests/model/softdelete/EBasicSoftDelete.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/EBasicSoftDelete.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/EBasicSoftDelete.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelBook.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelBook.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelBook.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelBook.java
index 249f6dfea..1c50b91dc 100644
--- a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelBook.java
+++ b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelBook.java
@@ -1,10 +1,6 @@
 package org.tests.model.softdelete;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.ManyToMany;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelDown.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelDown.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelDown.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelDown.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelMid.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelMid.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelMid.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelMid.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelOneA.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelOneA.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelOneA.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelOneA.java
index 3ecd9b044..6de682429 100644
--- a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelOneA.java
+++ b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelOneA.java
@@ -2,11 +2,7 @@ package org.tests.model.softdelete;
 
 import io.ebean.annotation.SoftDelete;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class ESoftDelOneA {
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelOneB.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelOneB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelOneB.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelOneB.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelRole.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelRole.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelRole.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelRole.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelTop.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelTop.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelTop.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelTop.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelUp.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelUp.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelUp.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelUp.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelUser.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelUser.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelUser.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelUser.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelX.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelX.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelX.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelX.java
index fbc3f9964..8b9ce71e7 100644
--- a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelX.java
+++ b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelX.java
@@ -2,7 +2,10 @@ package org.tests.model.softdelete;
 
 import io.ebean.annotation.SoftDelete;
 
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.ManyToOne;
+import javax.persistence.OneToOne;
 import java.util.UUID;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelY.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelY.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelY.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelY.java
index a65cc75c1..608343d56 100644
--- a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelY.java
+++ b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelY.java
@@ -2,7 +2,10 @@ package org.tests.model.softdelete;
 
 import io.ebean.annotation.SoftDelete;
 
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.ManyToOne;
+import javax.persistence.OneToOne;
 
 @Entity
 public class ESoftDelY {
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelZ.java b/ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelZ.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/ESoftDelZ.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/ESoftDelZ.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/EsdDetail.java b/ebean-test/src/test/java/org/tests/model/softdelete/EsdDetail.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/EsdDetail.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/EsdDetail.java
diff --git a/ebean-core/src/test/java/org/tests/model/softdelete/EsdMaster.java b/ebean-test/src/test/java/org/tests/model/softdelete/EsdMaster.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/softdelete/EsdMaster.java
rename to ebean-test/src/test/java/org/tests/model/softdelete/EsdMaster.java
diff --git a/ebean-core/src/test/java/org/tests/model/survey/Category.java b/ebean-test/src/test/java/org/tests/model/survey/Category.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/model/survey/Category.java
rename to ebean-test/src/test/java/org/tests/model/survey/Category.java
index c31b63550..9cbeca792 100644
--- a/ebean-core/src/test/java/org/tests/model/survey/Category.java
+++ b/ebean-test/src/test/java/org/tests/model/survey/Category.java
@@ -1,12 +1,6 @@
 package org.tests.model.survey;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderBy;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
@@ -41,7 +35,7 @@ public class Category {
   public void setSequenceNumber(int number) {
     this.sequenceNumber = number;
   }
-  
+
   public int getSequenceNumber() {
     return sequenceNumber;
   }
diff --git a/ebean-core/src/test/java/org/tests/model/survey/Group.java b/ebean-test/src/test/java/org/tests/model/survey/Group.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/model/survey/Group.java
rename to ebean-test/src/test/java/org/tests/model/survey/Group.java
index dcbc3fe83..5b1fb9e99 100644
--- a/ebean-core/src/test/java/org/tests/model/survey/Group.java
+++ b/ebean-test/src/test/java/org/tests/model/survey/Group.java
@@ -1,13 +1,6 @@
 package org.tests.model.survey;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderBy;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -44,7 +37,7 @@ public class Group {
   public void setSequenceNumber(int number) {
     this.sequenceNumber = number;
   }
-  
+
   public int getSequenceNumber() {
     return sequenceNumber;
   }
diff --git a/ebean-core/src/test/java/org/tests/model/survey/Question.java b/ebean-test/src/test/java/org/tests/model/survey/Question.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/survey/Question.java
rename to ebean-test/src/test/java/org/tests/model/survey/Question.java
diff --git a/ebean-core/src/test/java/org/tests/model/survey/Survey.java b/ebean-test/src/test/java/org/tests/model/survey/Survey.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/model/survey/Survey.java
rename to ebean-test/src/test/java/org/tests/model/survey/Survey.java
index 645ca9a50..328dd2ab2 100644
--- a/ebean-core/src/test/java/org/tests/model/survey/Survey.java
+++ b/ebean-test/src/test/java/org/tests/model/survey/Survey.java
@@ -1,10 +1,6 @@
 package org.tests.model.survey;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderBy;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/survey/TestOrderByFetch.java b/ebean-test/src/test/java/org/tests/model/survey/TestOrderByFetch.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/model/survey/TestOrderByFetch.java
rename to ebean-test/src/test/java/org/tests/model/survey/TestOrderByFetch.java
index b401696f0..ec3cbba19 100644
--- a/ebean-core/src/test/java/org/tests/model/survey/TestOrderByFetch.java
+++ b/ebean-test/src/test/java/org/tests/model/survey/TestOrderByFetch.java
@@ -1,13 +1,13 @@
 package org.tests.model.survey;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestOrderByFetch extends BaseTestCase {
 
@@ -38,9 +38,9 @@ public class TestOrderByFetch extends BaseTestCase {
     questionListGroup2.add(question(2));
     group2.setQuestions(questionListGroup2);
 
-    Ebean.save(survey);
+    DB.save(survey);
 
-    Survey foundSurvey = Ebean.find(Survey.class)
+    Survey foundSurvey = DB.find(Survey.class)
       .setDisableLazyLoading(true)
       .fetch("categories")
       .fetch("categories.groups")
diff --git a/ebean-core/src/test/java/org/tests/model/tevent/TEvent.java b/ebean-test/src/test/java/org/tests/model/tevent/TEvent.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/tevent/TEvent.java
rename to ebean-test/src/test/java/org/tests/model/tevent/TEvent.java
diff --git a/ebean-core/src/test/java/org/tests/model/tevent/TEventMany.java b/ebean-test/src/test/java/org/tests/model/tevent/TEventMany.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/tevent/TEventMany.java
rename to ebean-test/src/test/java/org/tests/model/tevent/TEventMany.java
diff --git a/ebean-core/src/test/java/org/tests/model/tevent/TEventOne.java b/ebean-test/src/test/java/org/tests/model/tevent/TEventOne.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/tevent/TEventOne.java
rename to ebean-test/src/test/java/org/tests/model/tevent/TEventOne.java
index f69ad23fe..896d5a147 100644
--- a/ebean-core/src/test/java/org/tests/model/tevent/TEventOne.java
+++ b/ebean-test/src/test/java/org/tests/model/tevent/TEventOne.java
@@ -2,12 +2,7 @@ package org.tests.model.tevent;
 
 import io.ebean.annotation.Aggregation;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.OneToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/tevent/TestAssocOneNullTraverse.java b/ebean-test/src/test/java/org/tests/model/tevent/TestAssocOneNullTraverse.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/model/tevent/TestAssocOneNullTraverse.java
rename to ebean-test/src/test/java/org/tests/model/tevent/TestAssocOneNullTraverse.java
index 377087985..4b74ceb75 100644
--- a/ebean-core/src/test/java/org/tests/model/tevent/TestAssocOneNullTraverse.java
+++ b/ebean-test/src/test/java/org/tests/model/tevent/TestAssocOneNullTraverse.java
@@ -1,8 +1,8 @@
 package org.tests.model.tevent;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 public class TestAssocOneNullTraverse extends BaseTestCase {
 
@@ -10,9 +10,9 @@ public class TestAssocOneNullTraverse extends BaseTestCase {
   public void test() {
 
     TEvent event = new TEvent("event");
-    Ebean.save(event);
+    DB.save(event);
 
-    Ebean.find(TEvent.class)
+    DB.find(TEvent.class)
       .fetch("one.logs")
       .findList();
   }
@@ -20,7 +20,7 @@ public class TestAssocOneNullTraverse extends BaseTestCase {
 //  @Test
 //  public void testSelectAggregation() {
 //
-//    Query<TEvent> query = Ebean.find(TEvent.class)
+//    Query<TEvent> query = DB.find(TEvent.class)
 //        .select("id, name")
 //        .fetch("one", "count");
 //
diff --git a/ebean-core/src/test/java/org/tests/model/types/SomeFileBean.java b/ebean-test/src/test/java/org/tests/model/types/SomeFileBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/types/SomeFileBean.java
rename to ebean-test/src/test/java/org/tests/model/types/SomeFileBean.java
diff --git a/ebean-core/src/test/java/org/tests/model/types/SomeNewTypesBean.java b/ebean-test/src/test/java/org/tests/model/types/SomeNewTypesBean.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/model/types/SomeNewTypesBean.java
rename to ebean-test/src/test/java/org/tests/model/types/SomeNewTypesBean.java
index 2397279cd..2596dbcba 100644
--- a/ebean-core/src/test/java/org/tests/model/types/SomeNewTypesBean.java
+++ b/ebean-test/src/test/java/org/tests/model/types/SomeNewTypesBean.java
@@ -6,21 +6,7 @@ import javax.persistence.Id;
 import javax.persistence.Version;
 import java.nio.file.Path;
 import java.sql.Date;
-import java.time.DayOfWeek;
-import java.time.Duration;
-import java.time.Instant;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.LocalTime;
-import java.time.Month;
-import java.time.MonthDay;
-import java.time.OffsetDateTime;
-import java.time.Period;
-import java.time.Year;
-import java.time.YearMonth;
-import java.time.ZoneId;
-import java.time.ZoneOffset;
-import java.time.ZonedDateTime;
+import java.time.*;
 
 @Entity
 public class SomeNewTypesBean {
diff --git a/ebean-core/src/test/java/org/tests/model/types/SomePeriodBean.java b/ebean-test/src/test/java/org/tests/model/types/SomePeriodBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/types/SomePeriodBean.java
rename to ebean-test/src/test/java/org/tests/model/types/SomePeriodBean.java
diff --git a/ebean-test/src/test/java/org/tests/model/uuidsibling/SoftDeleteCascadeTest.java b/ebean-test/src/test/java/org/tests/model/uuidsibling/SoftDeleteCascadeTest.java
new file mode 100644
index 000000000..25e56347b
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/model/uuidsibling/SoftDeleteCascadeTest.java
@@ -0,0 +1,47 @@
+package org.tests.model.uuidsibling;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class SoftDeleteCascadeTest {
+
+  @Test
+  public void testDeleteParent() {
+    // Insert + link records
+    USibParent parent = new USibParent();
+    parent.save();
+
+    USibChild child = new USibChild(parent);
+    child.save();
+
+    USibChildSibling childSibling = new USibChildSibling(child);
+    childSibling.save();
+
+    Long parentId = parent.getId();
+    UUID childId = child.getId();
+    Long childSiblingId = childSibling.getId();
+
+    assertBefore(parent, child, childSibling);
+    parent.delete();
+    assertAfter(parentId, childId, childSiblingId);
+  }
+
+  private void assertBefore(USibParent parent, USibChild child, USibChildSibling childSibling) {
+
+    parent.refresh();
+
+    assertThat(parent.getChildren()).hasSize(1);
+    assertThat(parent.getChildren().get(0).getId()).isEqualTo(child.getId());
+    assertThat(parent.getChildren().get(0).getChildSibling()).isNotNull();
+    assertThat(parent.getChildren().get(0).getChildSibling().getId()).isEqualTo(childSibling.getId());
+  }
+
+  private void assertAfter(Long parentId, UUID childId, Long childSiblingId) {
+    assertThat(USibParent.find.byId(parentId)).isNull();
+    assertThat(USibChild.find.byId(childId)).isNull();
+    assertThat(USibChildSibling.find.byId(childSiblingId)).isNull();
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/model/uuidsibling/USibChild.java b/ebean-test/src/test/java/org/tests/model/uuidsibling/USibChild.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/uuidsibling/USibChild.java
rename to ebean-test/src/test/java/org/tests/model/uuidsibling/USibChild.java
index 7fa10caea..dd28ae184 100644
--- a/ebean-core/src/test/java/org/tests/model/uuidsibling/USibChild.java
+++ b/ebean-test/src/test/java/org/tests/model/uuidsibling/USibChild.java
@@ -4,11 +4,7 @@ import io.ebean.Finder;
 import io.ebean.Model;
 import io.ebean.annotation.SoftDelete;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToOne;
+import javax.persistence.*;
 import java.io.Serializable;
 import java.util.UUID;
 
diff --git a/ebean-core/src/test/java/org/tests/model/uuidsibling/USibChildSibling.java b/ebean-test/src/test/java/org/tests/model/uuidsibling/USibChildSibling.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/uuidsibling/USibChildSibling.java
rename to ebean-test/src/test/java/org/tests/model/uuidsibling/USibChildSibling.java
diff --git a/ebean-core/src/test/java/org/tests/model/uuidsibling/USibParent.java b/ebean-test/src/test/java/org/tests/model/uuidsibling/USibParent.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/uuidsibling/USibParent.java
rename to ebean-test/src/test/java/org/tests/model/uuidsibling/USibParent.java
diff --git a/ebean-core/src/test/java/org/tests/model/version/TestVersionHierarchyModification.java b/ebean-test/src/test/java/org/tests/model/version/TestVersionHierarchyModification.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/model/version/TestVersionHierarchyModification.java
rename to ebean-test/src/test/java/org/tests/model/version/TestVersionHierarchyModification.java
index 8c7608450..b318e643f 100644
--- a/ebean-core/src/test/java/org/tests/model/version/TestVersionHierarchyModification.java
+++ b/ebean-test/src/test/java/org/tests/model/version/TestVersionHierarchyModification.java
@@ -1,16 +1,16 @@
 package org.tests.model.version;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestVersionHierarchyModification extends BaseTestCase {
 
-  @Before
+  @BeforeEach
   public void setup() {
     final VersionParent parent = new VersionParent();
     parent.setName("vParent");
@@ -39,17 +39,17 @@ public class TestVersionHierarchyModification extends BaseTestCase {
     toy22.setName("vToy2.2");
     child2.getToys().add(toy22);
 
-    Ebean.save(parent);
+    DB.save(parent);
   }
 
-  @After
+  @AfterEach
   public void cleanUp() {
-    Ebean.find(VersionParent.class).delete();
+    DB.find(VersionParent.class).delete();
   }
 
   @Test
   public void testMoveDown() {
-    VersionParent parent = Ebean.find(VersionParent.class).findOne();
+    VersionParent parent = DB.find(VersionParent.class).findOne();
     assertThat(parent).isNotNull();
     assertThat(parent.getChildren()).hasSize(2);
 
@@ -66,9 +66,9 @@ public class TestVersionHierarchyModification extends BaseTestCase {
     toyToMove.setChild(secondChild);
     secondChild.getToys().add(1, toyToMove);
 
-    Ebean.save(parent);
+    DB.save(parent);
 
-    parent = Ebean.find(VersionParent.class).findOne();
+    parent = DB.find(VersionParent.class).findOne();
     assertThat(parent).isNotNull();
     assertThat(parent.getChildren()).hasSize(2);
 
@@ -83,7 +83,7 @@ public class TestVersionHierarchyModification extends BaseTestCase {
 
   @Test
   public void testMoveUp() {
-    VersionParent parent = Ebean.find(VersionParent.class).findOne();
+    VersionParent parent = DB.find(VersionParent.class).findOne();
     assertThat(parent).isNotNull();
     assertThat(parent.getChildren()).hasSize(2);
 
@@ -100,9 +100,9 @@ public class TestVersionHierarchyModification extends BaseTestCase {
     toyToMove.setChild(firstChild);
     firstChild.getToys().add(1, toyToMove);
 
-    Ebean.save(parent);
+    DB.save(parent);
 
-    parent = Ebean.find(VersionParent.class).findOne();
+    parent = DB.find(VersionParent.class).findOne();
     assertThat(parent).isNotNull();
     assertThat(parent.getChildren()).hasSize(2);
 
diff --git a/ebean-core/src/test/java/org/tests/model/version/VersionChild.java b/ebean-test/src/test/java/org/tests/model/version/VersionChild.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/version/VersionChild.java
rename to ebean-test/src/test/java/org/tests/model/version/VersionChild.java
index 03e4725b1..26223b801 100644
--- a/ebean-core/src/test/java/org/tests/model/version/VersionChild.java
+++ b/ebean-test/src/test/java/org/tests/model/version/VersionChild.java
@@ -1,12 +1,6 @@
 package org.tests.model.version;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/version/VersionParent.java b/ebean-test/src/test/java/org/tests/model/version/VersionParent.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/model/version/VersionParent.java
rename to ebean-test/src/test/java/org/tests/model/version/VersionParent.java
index 288992225..fdcce6782 100644
--- a/ebean-core/src/test/java/org/tests/model/version/VersionParent.java
+++ b/ebean-test/src/test/java/org/tests/model/version/VersionParent.java
@@ -1,11 +1,6 @@
 package org.tests.model.version;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderColumn;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/model/version/VersionToy.java b/ebean-test/src/test/java/org/tests/model/version/VersionToy.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/model/version/VersionToy.java
rename to ebean-test/src/test/java/org/tests/model/version/VersionToy.java
diff --git a/ebean-core/src/test/java/org/tests/model/view/EOrderAgg.java b/ebean-test/src/test/java/org/tests/model/view/EOrderAgg.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/model/view/EOrderAgg.java
rename to ebean-test/src/test/java/org/tests/model/view/EOrderAgg.java
index 8a38ef15c..1700e0f2d 100644
--- a/ebean-core/src/test/java/org/tests/model/view/EOrderAgg.java
+++ b/ebean-test/src/test/java/org/tests/model/view/EOrderAgg.java
@@ -4,11 +4,7 @@ import io.ebean.annotation.Cache;
 import io.ebean.annotation.View;
 import org.tests.model.basic.Order;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.OneToOne;
+import javax.persistence.*;
 
 @Cache(enableQueryCache = true)
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/model/view/TestViewBaseEntity.java b/ebean-test/src/test/java/org/tests/model/view/TestViewBaseEntity.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/model/view/TestViewBaseEntity.java
rename to ebean-test/src/test/java/org/tests/model/view/TestViewBaseEntity.java
index a341644af..5f91694b1 100644
--- a/ebean-core/src/test/java/org/tests/model/view/TestViewBaseEntity.java
+++ b/ebean-test/src/test/java/org/tests/model/view/TestViewBaseEntity.java
@@ -1,9 +1,9 @@
 package org.tests.model.view;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.ResetBasicData;
@@ -19,7 +19,7 @@ public class TestViewBaseEntity extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<EOrderAgg> query = Ebean.find(EOrderAgg.class)
+    Query<EOrderAgg> query = DB.find(EOrderAgg.class)
       .where().gt("orderTotal", 20)
       .query();
 
@@ -34,7 +34,7 @@ public class TestViewBaseEntity extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<EOrderAgg> query = Ebean.find(EOrderAgg.class)
+    Query<EOrderAgg> query = DB.find(EOrderAgg.class)
       //.fetch("order", "id")
       .where().gt("orderTotal", 20)
       .query();
@@ -52,7 +52,7 @@ public class TestViewBaseEntity extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<EOrderAgg> query = Ebean.find(EOrderAgg.class)
+    Query<EOrderAgg> query = DB.find(EOrderAgg.class)
       .fetch("order")
       .fetch("order.details")
       .where().gt("orderTotal", 20)
diff --git a/ebean-core/src/test/java/org/tests/model/zero/TestWithZero.java b/ebean-test/src/test/java/org/tests/model/zero/TestWithZero.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/model/zero/TestWithZero.java
rename to ebean-test/src/test/java/org/tests/model/zero/TestWithZero.java
index ce7b68719..71a87432b 100644
--- a/ebean-core/src/test/java/org/tests/model/zero/TestWithZero.java
+++ b/ebean-test/src/test/java/org/tests/model/zero/TestWithZero.java
@@ -1,11 +1,11 @@
 package org.tests.model.zero;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestWithZero extends BaseTestCase {
 
@@ -21,12 +21,12 @@ public class TestWithZero extends BaseTestCase {
     WithZeroParent parent = new WithZeroParent();
     parent.getChildren().add(withZero);
 
-    Ebean.save(parent);
+    DB.save(parent);
 
     parent.getChildren().add(new WithZero());
 
     //withZero.setName("Foo");
-    Ebean.save(parent);
+    DB.save(parent);
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/model/zero/WithZero.java b/ebean-test/src/test/java/org/tests/model/zero/WithZero.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/model/zero/WithZero.java
rename to ebean-test/src/test/java/org/tests/model/zero/WithZero.java
index 460478d16..3f961f85e 100644
--- a/ebean-core/src/test/java/org/tests/model/zero/WithZero.java
+++ b/ebean-test/src/test/java/org/tests/model/zero/WithZero.java
@@ -1,10 +1,6 @@
 package org.tests.model.zero;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 public class WithZero {
diff --git a/ebean-core/src/test/java/org/tests/model/zero/WithZeroParent.java b/ebean-test/src/test/java/org/tests/model/zero/WithZeroParent.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/model/zero/WithZeroParent.java
rename to ebean-test/src/test/java/org/tests/model/zero/WithZeroParent.java
index 610e747c8..c6ea43821 100644
--- a/ebean-core/src/test/java/org/tests/model/zero/WithZeroParent.java
+++ b/ebean-test/src/test/java/org/tests/model/zero/WithZeroParent.java
@@ -1,11 +1,6 @@
 package org.tests.model.zero;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/o2m/OMVertex.java b/ebean-test/src/test/java/org/tests/o2m/OMVertex.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2m/OMVertex.java
rename to ebean-test/src/test/java/org/tests/o2m/OMVertex.java
diff --git a/ebean-core/src/test/java/org/tests/o2m/OMVertexOther.java b/ebean-test/src/test/java/org/tests/o2m/OMVertexOther.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2m/OMVertexOther.java
rename to ebean-test/src/test/java/org/tests/o2m/OMVertexOther.java
diff --git a/ebean-core/src/test/java/org/tests/o2m/OmAccountChildDBO.java b/ebean-test/src/test/java/org/tests/o2m/OmAccountChildDBO.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2m/OmAccountChildDBO.java
rename to ebean-test/src/test/java/org/tests/o2m/OmAccountChildDBO.java
diff --git a/ebean-core/src/test/java/org/tests/o2m/OmAccountDBO.java b/ebean-test/src/test/java/org/tests/o2m/OmAccountDBO.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2m/OmAccountDBO.java
rename to ebean-test/src/test/java/org/tests/o2m/OmAccountDBO.java
diff --git a/ebean-core/src/test/java/org/tests/o2m/OmBasicChild.java b/ebean-test/src/test/java/org/tests/o2m/OmBasicChild.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2m/OmBasicChild.java
rename to ebean-test/src/test/java/org/tests/o2m/OmBasicChild.java
diff --git a/ebean-core/src/test/java/org/tests/o2m/OmBasicParent.java b/ebean-test/src/test/java/org/tests/o2m/OmBasicParent.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/o2m/OmBasicParent.java
rename to ebean-test/src/test/java/org/tests/o2m/OmBasicParent.java
index 15b117bd0..76f23c86a 100644
--- a/ebean-core/src/test/java/org/tests/o2m/OmBasicParent.java
+++ b/ebean-test/src/test/java/org/tests/o2m/OmBasicParent.java
@@ -1,12 +1,11 @@
 package org.tests.o2m;
 
+import io.ebean.annotation.Where;
+
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.OneToMany;
 import javax.persistence.Version;
-
-import io.ebean.annotation.Where;
-
 import java.util.List;
 
 import static javax.persistence.CascadeType.ALL;
diff --git a/ebean-core/src/test/java/org/tests/o2m/TestOneToManyNoMappedBy.java b/ebean-test/src/test/java/org/tests/o2m/TestOneToManyNoMappedBy.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/o2m/TestOneToManyNoMappedBy.java
rename to ebean-test/src/test/java/org/tests/o2m/TestOneToManyNoMappedBy.java
index cb95ad388..47e2eff50 100644
--- a/ebean-core/src/test/java/org/tests/o2m/TestOneToManyNoMappedBy.java
+++ b/ebean-test/src/test/java/org/tests/o2m/TestOneToManyNoMappedBy.java
@@ -2,14 +2,14 @@ package org.tests.o2m;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
 
 public class TestOneToManyNoMappedBy extends BaseTestCase {
 
@@ -22,7 +22,7 @@ public class TestOneToManyNoMappedBy extends BaseTestCase {
 
     account.save();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     final OmAccountDBO found = DB.find(OmAccountDBO.class)
       .where().eq("name", "one")
@@ -35,7 +35,7 @@ public class TestOneToManyNoMappedBy extends BaseTestCase {
       assertSame(found, child.getBananaRama());
     }
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(1)).contains("select t0.banana_rama_id, t0.id, t0.description, t0.banana_rama_id from om_account_child_dbo t0 where");
   }
diff --git a/ebean-core/src/test/java/org/tests/o2m/TestOneToManyOnlyBean.java b/ebean-test/src/test/java/org/tests/o2m/TestOneToManyOnlyBean.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/o2m/TestOneToManyOnlyBean.java
rename to ebean-test/src/test/java/org/tests/o2m/TestOneToManyOnlyBean.java
index 2dccb4a1e..c1d7b40b6 100644
--- a/ebean-core/src/test/java/org/tests/o2m/TestOneToManyOnlyBean.java
+++ b/ebean-test/src/test/java/org/tests/o2m/TestOneToManyOnlyBean.java
@@ -4,13 +4,11 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.bean.EntityBean;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.UUID;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestOneToManyOnlyBean extends BaseTestCase {
 
@@ -33,7 +31,7 @@ public class TestOneToManyOnlyBean extends BaseTestCase {
   @Test
   public void isReference_when_getReference_expectTrue() {
 
-    OMVertex myBean = DB.getReference(OMVertex.class, UUID.randomUUID());
+    OMVertex myBean = DB.reference(OMVertex.class, UUID.randomUUID());
     assertTrue(isReference(myBean));
   }
 
diff --git a/ebean-core/src/test/java/org/tests/o2m/TestOneToManyWhere.java b/ebean-test/src/test/java/org/tests/o2m/TestOneToManyWhere.java
similarity index 95%
rename from ebean-core/src/test/java/org/tests/o2m/TestOneToManyWhere.java
rename to ebean-test/src/test/java/org/tests/o2m/TestOneToManyWhere.java
index e2dca664a..e60142a8f 100644
--- a/ebean-core/src/test/java/org/tests/o2m/TestOneToManyWhere.java
+++ b/ebean-test/src/test/java/org/tests/o2m/TestOneToManyWhere.java
@@ -2,9 +2,8 @@ package org.tests.o2m;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebeantest.LoggedSql;
-
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/o2m/TestOneToManyWildcard.java b/ebean-test/src/test/java/org/tests/o2m/TestOneToManyWildcard.java
similarity index 95%
rename from ebean-core/src/test/java/org/tests/o2m/TestOneToManyWildcard.java
rename to ebean-test/src/test/java/org/tests/o2m/TestOneToManyWildcard.java
index 2cf5561c8..6b4674a94 100644
--- a/ebean-core/src/test/java/org/tests/o2m/TestOneToManyWildcard.java
+++ b/ebean-test/src/test/java/org/tests/o2m/TestOneToManyWildcard.java
@@ -1,7 +1,7 @@
 package org.tests.o2m;
 
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 
diff --git a/ebean-core/src/test/java/org/tests/o2m/jointable/JtMonkey.java b/ebean-test/src/test/java/org/tests/o2m/jointable/JtMonkey.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2m/jointable/JtMonkey.java
rename to ebean-test/src/test/java/org/tests/o2m/jointable/JtMonkey.java
diff --git a/ebean-core/src/test/java/org/tests/o2m/jointable/JtMonkeyGroup.java b/ebean-test/src/test/java/org/tests/o2m/jointable/JtMonkeyGroup.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/o2m/jointable/JtMonkeyGroup.java
rename to ebean-test/src/test/java/org/tests/o2m/jointable/JtMonkeyGroup.java
index 496782f2b..4e335aa0c 100644
--- a/ebean-core/src/test/java/org/tests/o2m/jointable/JtMonkeyGroup.java
+++ b/ebean-test/src/test/java/org/tests/o2m/jointable/JtMonkeyGroup.java
@@ -1,11 +1,6 @@
 package org.tests.o2m.jointable;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinTable;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/o2m/jointable/JtTrainer.java b/ebean-test/src/test/java/org/tests/o2m/jointable/JtTrainer.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/o2m/jointable/JtTrainer.java
rename to ebean-test/src/test/java/org/tests/o2m/jointable/JtTrainer.java
index 66a2e3474..5782c220f 100644
--- a/ebean-core/src/test/java/org/tests/o2m/jointable/JtTrainer.java
+++ b/ebean-test/src/test/java/org/tests/o2m/jointable/JtTrainer.java
@@ -1,12 +1,6 @@
 package org.tests.o2m.jointable;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinTable;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/o2m/jointable/JtTroop.java b/ebean-test/src/test/java/org/tests/o2m/jointable/JtTroop.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/o2m/jointable/JtTroop.java
rename to ebean-test/src/test/java/org/tests/o2m/jointable/JtTroop.java
index 06a4b79eb..db64e6be2 100644
--- a/ebean-core/src/test/java/org/tests/o2m/jointable/JtTroop.java
+++ b/ebean-test/src/test/java/org/tests/o2m/jointable/JtTroop.java
@@ -1,11 +1,6 @@
 package org.tests.o2m.jointable;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinTable;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTable.java b/ebean-test/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTable.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTable.java
rename to ebean-test/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTable.java
index 1fb128e09..0d035fbd5 100644
--- a/ebean-core/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTable.java
+++ b/ebean-test/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTable.java
@@ -2,8 +2,8 @@ package org.tests.o2m.jointable;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 import java.util.List;
@@ -27,7 +27,7 @@ public class TestOneToManyJoinTable extends BaseTestCase {
 
     initialInsert();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // make m0 dirty ... but no cascade saved?
     m0.setFoodPreference("banana");
@@ -36,7 +36,7 @@ public class TestOneToManyJoinTable extends BaseTestCase {
 
     DB.save(troop);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(3);
       assertSql(sql.get(0)).contains("insert into troop_monkey (troop_pid, monkey_mid) values (?, ?)");
@@ -50,11 +50,11 @@ public class TestOneToManyJoinTable extends BaseTestCase {
 
     long intersectionRows = DB.sqlQuery("select count(*) as total from troop_monkey where troop_pid = ?")
       .setParameter(1, troop.getPid())
-      .findSingleLong();
+      .mapToScalar(Long.class).findOne();
 
     assertThat(intersectionRows).isEqualTo(2L);
 
-    LoggedSqlCollector.current();
+    LoggedSql.collect();
     JtTroop fetchTroop = DB.find(JtTroop.class)
       .fetch("monkeys")
       .where().idEq(troop.getPid())
@@ -62,14 +62,14 @@ public class TestOneToManyJoinTable extends BaseTestCase {
 
     assertThat(fetchTroop.getMonkeys()).hasSize(2);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("from troop t0 left join troop_monkey t1z_ on t1z_.troop_pid = t0.pid left join monkey t1 on t1.mid = t1z_.monkey_mid where t0.pid = ?");
     assertSql(sql.get(0)).contains("select t0.pid, t0.name, t0.version, t1.mid, t1.name, t1.food_preference, t1.version");
 
     DB.delete(troop);
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from troop_monkey where troop_pid = ?");
     assertSql(sql.get(1)).contains("delete from troop where pid=? and version=?");
@@ -85,15 +85,15 @@ public class TestOneToManyJoinTable extends BaseTestCase {
     // make m2 dirty ... cascades to an update on Uim
     m2.setFoodPreference("Apple");
     trainer.getMonkeys().add(m2);
-    trainer.getMonkeys().add(DB.getReference(JtMonkey.class, m1.getMid()));
+    trainer.getMonkeys().add(DB.reference(JtMonkey.class, m1.getMid()));
     trainer.getMonkeys().add(new JtMonkey("FAlp"));
     trainer.getMonkeys().add(new JtMonkey("FBet"));
     trainer.getMonkeys().add(new JtMonkey("FThe"));
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.save(trainer);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
 
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(13);
@@ -123,10 +123,10 @@ public class TestOneToManyJoinTable extends BaseTestCase {
     assertThat(intersectionRows).isEqualTo(5);
 
 
-    LoggedSqlCollector.current();
+    LoggedSql.collect();
     DB.delete(trainer);
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from trainer_monkey where trainer_tid = ?");
     assertSql(sql.get(1)).contains("delete from trainer where tid=?");
diff --git a/ebean-core/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableInheritance.java b/ebean-test/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableInheritance.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableInheritance.java
rename to ebean-test/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableInheritance.java
index 19e600b7b..9413f6cfd 100644
--- a/ebean-core/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableInheritance.java
+++ b/ebean-test/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableInheritance.java
@@ -1,11 +1,10 @@
 package org.tests.o2m.jointable;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.config.dbplatform.IdType;
-
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.o2m.jointable.inheritance.ClassA;
 import org.tests.o2m.jointable.inheritance.ClassB;
 
@@ -30,11 +29,11 @@ public class TestOneToManyJoinTableInheritance extends BaseTestCase {
     classA.getMonkeys().add(m1);
     classB.getMonkeys().add(m2);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.saveAll(Arrays.asList(classA, classB));
+    DB.saveAll(Arrays.asList(classA, classB));
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
 
     assertThat(sql).hasSize(11);
     assertSql(sql.get(0)).contains("insert into class_super ");
@@ -51,8 +50,8 @@ public class TestOneToManyJoinTableInheritance extends BaseTestCase {
     }
     assertSqlBind(sql, 8, 10);
 
-    ClassA dbA = Ebean.find(ClassA.class, 1);
-    ClassB dbB = Ebean.find(ClassB.class, 2);
+    ClassA dbA = DB.find(ClassA.class, 1);
+    ClassB dbB = DB.find(ClassB.class, 2);
 
     assertThat(dbA.getMonkeys()).hasSize(2);
     assertThat(dbB.getMonkeys()).hasSize(1);
diff --git a/ebean-core/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableNoTableName.java b/ebean-test/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableNoTableName.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableNoTableName.java
rename to ebean-test/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableNoTableName.java
index 500a0ef79..ee58d1964 100644
--- a/ebean-core/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableNoTableName.java
+++ b/ebean-test/src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableNoTableName.java
@@ -2,9 +2,8 @@ package org.tests.o2m.jointable;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 import java.util.List;
@@ -20,7 +19,7 @@ public class TestOneToManyJoinTableNoTableName extends BaseTestCase {
   private JtMonkey m2 = new JtMonkey("Uim3");
 
   private void initialInsert() {
-    Ebean.saveAll(Arrays.asList(troop, m0, m1, m2));
+    DB.saveAll(Arrays.asList(troop, m0, m1, m2));
   }
 
   @Test
@@ -28,16 +27,16 @@ public class TestOneToManyJoinTableNoTableName extends BaseTestCase {
 
     initialInsert();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // make m0 dirty ... but no cascade saved?
     m0.setFoodPreference("camera");
     troop.getMonkeys().add(m0);
     troop.getMonkeys().add(m1);
 
-    Ebean.save(troop);
+    DB.save(troop);
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     if (isPersistBatchOnCascade()) {
       assertThat(sql).hasSize(3);
       assertSql(sql.get(0)).contains("insert into mkeygroup_monkey (mkeygroup_pid, monkey_mid) values (?, ?)");
@@ -55,22 +54,22 @@ public class TestOneToManyJoinTableNoTableName extends BaseTestCase {
 
     assertThat(intersectionRows).isEqualTo(2);
 
-    LoggedSqlCollector.current();
-    JtMonkeyGroup fetchTroop = Ebean.find(JtMonkeyGroup.class)
+    LoggedSql.collect();
+    JtMonkeyGroup fetchTroop = DB.find(JtMonkeyGroup.class)
       .fetch("monkeys")
       .where().idEq(troop.getPid())
       .findOne();
 
     assertThat(fetchTroop.getMonkeys()).hasSize(2);
 
-    sql = LoggedSqlCollector.current();
+    sql = LoggedSql.collect();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("from mkeygroup t0 left join mkeygroup_monkey t1z_ on t1z_.mkeygroup_pid = t0.pid left join monkey t1 on t1.mid = t1z_.monkey_mid where t0.pid = ?");
     assertSql(sql.get(0)).contains("select t0.pid, t0.name, t0.version, t1.mid, t1.name, t1.food_preference, t1.version");
 
-    Ebean.delete(troop);
+    DB.delete(troop);
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("delete from mkeygroup_monkey where mkeygroup_pid = ?");
     assertSql(sql.get(1)).contains("delete from mkeygroup where pid=? and version=?");
diff --git a/ebean-core/src/test/java/org/tests/o2m/jointable/inheritance/ClassA.java b/ebean-test/src/test/java/org/tests/o2m/jointable/inheritance/ClassA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2m/jointable/inheritance/ClassA.java
rename to ebean-test/src/test/java/org/tests/o2m/jointable/inheritance/ClassA.java
diff --git a/ebean-core/src/test/java/org/tests/o2m/jointable/inheritance/ClassB.java b/ebean-test/src/test/java/org/tests/o2m/jointable/inheritance/ClassB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2m/jointable/inheritance/ClassB.java
rename to ebean-test/src/test/java/org/tests/o2m/jointable/inheritance/ClassB.java
diff --git a/ebean-core/src/test/java/org/tests/o2m/jointable/inheritance/ClassSuper.java b/ebean-test/src/test/java/org/tests/o2m/jointable/inheritance/ClassSuper.java
similarity index 61%
rename from ebean-core/src/test/java/org/tests/o2m/jointable/inheritance/ClassSuper.java
rename to ebean-test/src/test/java/org/tests/o2m/jointable/inheritance/ClassSuper.java
index 08d3bbf54..2b62d81bf 100644
--- a/ebean-core/src/test/java/org/tests/o2m/jointable/inheritance/ClassSuper.java
+++ b/ebean-test/src/test/java/org/tests/o2m/jointable/inheritance/ClassSuper.java
@@ -2,12 +2,7 @@ package org.tests.o2m.jointable.inheritance;
 
 import org.tests.o2m.jointable.JtMonkey;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.JoinTable;
-import javax.persistence.OneToMany;
+import javax.persistence.*;
 import java.util.List;
 
 @Inheritance
diff --git a/ebean-core/src/test/java/org/tests/o2m/lazy/OmlBar.java b/ebean-test/src/test/java/org/tests/o2m/lazy/OmlBar.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/o2m/lazy/OmlBar.java
rename to ebean-test/src/test/java/org/tests/o2m/lazy/OmlBar.java
index 6e35c1e17..b5b18eb6d 100644
--- a/ebean-core/src/test/java/org/tests/o2m/lazy/OmlBar.java
+++ b/ebean-test/src/test/java/org/tests/o2m/lazy/OmlBar.java
@@ -1,10 +1,6 @@
 package org.tests.o2m.lazy;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/o2m/lazy/OmlBaz.java b/ebean-test/src/test/java/org/tests/o2m/lazy/OmlBaz.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2m/lazy/OmlBaz.java
rename to ebean-test/src/test/java/org/tests/o2m/lazy/OmlBaz.java
diff --git a/ebean-core/src/test/java/org/tests/o2m/lazy/OmlFoo.java b/ebean-test/src/test/java/org/tests/o2m/lazy/OmlFoo.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/o2m/lazy/OmlFoo.java
rename to ebean-test/src/test/java/org/tests/o2m/lazy/OmlFoo.java
index 52d428d07..8195d1757 100644
--- a/ebean-core/src/test/java/org/tests/o2m/lazy/OmlFoo.java
+++ b/ebean-test/src/test/java/org/tests/o2m/lazy/OmlFoo.java
@@ -1,11 +1,6 @@
 package org.tests.o2m.lazy;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/o2m/lazy/TestLazyManyViaPath.java b/ebean-test/src/test/java/org/tests/o2m/lazy/TestLazyManyViaPath.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/o2m/lazy/TestLazyManyViaPath.java
rename to ebean-test/src/test/java/org/tests/o2m/lazy/TestLazyManyViaPath.java
index 8eee5d3e8..f6c41bebe 100644
--- a/ebean-core/src/test/java/org/tests/o2m/lazy/TestLazyManyViaPath.java
+++ b/ebean-test/src/test/java/org/tests/o2m/lazy/TestLazyManyViaPath.java
@@ -2,7 +2,7 @@ package org.tests.o2m.lazy;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/ebean-core/src/test/java/org/tests/o2o/OtoLevelA.java b/ebean-test/src/test/java/org/tests/o2o/OtoLevelA.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2o/OtoLevelA.java
rename to ebean-test/src/test/java/org/tests/o2o/OtoLevelA.java
diff --git a/ebean-core/src/test/java/org/tests/o2o/OtoLevelB.java b/ebean-test/src/test/java/org/tests/o2o/OtoLevelB.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2o/OtoLevelB.java
rename to ebean-test/src/test/java/org/tests/o2o/OtoLevelB.java
diff --git a/ebean-core/src/test/java/org/tests/o2o/OtoLevelC.java b/ebean-test/src/test/java/org/tests/o2o/OtoLevelC.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/o2o/OtoLevelC.java
rename to ebean-test/src/test/java/org/tests/o2o/OtoLevelC.java
diff --git a/ebean-core/src/test/java/org/tests/o2o/TestOneToOneSaveWithoutChanges.java b/ebean-test/src/test/java/org/tests/o2o/TestOneToOneSaveWithoutChanges.java
similarity index 57%
rename from ebean-core/src/test/java/org/tests/o2o/TestOneToOneSaveWithoutChanges.java
rename to ebean-test/src/test/java/org/tests/o2o/TestOneToOneSaveWithoutChanges.java
index a80277abd..5621d4ce8 100644
--- a/ebean-core/src/test/java/org/tests/o2o/TestOneToOneSaveWithoutChanges.java
+++ b/ebean-test/src/test/java/org/tests/o2o/TestOneToOneSaveWithoutChanges.java
@@ -1,9 +1,9 @@
 package org.tests.o2o;
 
 
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -18,19 +18,19 @@ public class TestOneToOneSaveWithoutChanges {
     a.setB(new OtoLevelB("B"));
     a.getB().setC(new OtoLevelC("C"));
 
-    Ebean.save(a);
+    DB.save(a);
 
-    OtoLevelA dbA = Ebean.find(OtoLevelA.class, 1);
+    OtoLevelA dbA = DB.find(OtoLevelA.class, 1);
     OtoLevelB dbB = dbA.getB();
     OtoLevelC dbC = dbB.getC();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.save(dbA);
-    Ebean.save(dbB);
-    Ebean.save(dbC);
+    DB.save(dbA);
+    DB.save(dbB);
+    DB.save(dbC);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(0);
   }
 }
diff --git a/ebean-test/src/test/java/org/tests/o2o/TestReferenceSave.java b/ebean-test/src/test/java/org/tests/o2o/TestReferenceSave.java
new file mode 100644
index 000000000..abc70c061
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/o2o/TestReferenceSave.java
@@ -0,0 +1,28 @@
+package org.tests.o2o;
+
+
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
+import org.tests.update.EPersonOnline;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestReferenceSave {
+
+  @Test
+  public void test() {
+
+    DB.getDefault();
+
+    LoggedSql.start();
+
+    EPersonOnline bean = DB.reference(EPersonOnline.class, 1L);
+    DB.save(bean);
+
+    List<String> sql = LoggedSql.collect();
+    assertThat(sql).hasSize(0);
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/order/OrderMaster.java b/ebean-test/src/test/java/org/tests/order/OrderMaster.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/order/OrderMaster.java
rename to ebean-test/src/test/java/org/tests/order/OrderMaster.java
diff --git a/ebean-core/src/test/java/org/tests/order/OrderReferencedChild.java b/ebean-test/src/test/java/org/tests/order/OrderReferencedChild.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/order/OrderReferencedChild.java
rename to ebean-test/src/test/java/org/tests/order/OrderReferencedChild.java
index 47a2f6ed5..4e1751cab 100644
--- a/ebean-core/src/test/java/org/tests/order/OrderReferencedChild.java
+++ b/ebean-test/src/test/java/org/tests/order/OrderReferencedChild.java
@@ -1,11 +1,6 @@
 package org.tests.order;
 
-import javax.persistence.CascadeType;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.Entity;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderColumn;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/order/OrderReferencedParent.java b/ebean-test/src/test/java/org/tests/order/OrderReferencedParent.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/order/OrderReferencedParent.java
rename to ebean-test/src/test/java/org/tests/order/OrderReferencedParent.java
index b98e9f2eb..19ea3481c 100644
--- a/ebean-core/src/test/java/org/tests/order/OrderReferencedParent.java
+++ b/ebean-test/src/test/java/org/tests/order/OrderReferencedParent.java
@@ -2,12 +2,7 @@ package org.tests.order;
 
 import io.ebean.annotation.Index;
 
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.MappedSuperclass;
+import javax.persistence.*;
 
 @Entity
 @MappedSuperclass
diff --git a/ebean-core/src/test/java/org/tests/order/OrderToy.java b/ebean-test/src/test/java/org/tests/order/OrderToy.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/order/OrderToy.java
rename to ebean-test/src/test/java/org/tests/order/OrderToy.java
diff --git a/ebean-core/src/test/java/org/tests/order/TestOrderColumn.java b/ebean-test/src/test/java/org/tests/order/TestOrderColumn.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/order/TestOrderColumn.java
rename to ebean-test/src/test/java/org/tests/order/TestOrderColumn.java
index a3722daad..e6604035d 100644
--- a/ebean-core/src/test/java/org/tests/order/TestOrderColumn.java
+++ b/ebean-test/src/test/java/org/tests/order/TestOrderColumn.java
@@ -1,9 +1,9 @@
 package org.tests.order;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.TransactionalTestCase;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.Comparator;
 import java.util.List;
@@ -23,9 +23,9 @@ public class TestOrderColumn extends TransactionalTestCase {
       master.getChildren().add(child);
     }
 
-    Ebean.save(master);
+    DB.save(master);
 
-    final OrderMaster result = Ebean.find(OrderMaster.class).findOne();
+    final OrderMaster result = DB.find(OrderMaster.class).findOne();
 
     assertThat(result.getChildren()).hasSize(5);
     assertThat(result.getChildren()).extracting(OrderReferencedChild::getName).containsExactly("p0", "p1", "p2", "p3", "p4");
@@ -43,9 +43,9 @@ public class TestOrderColumn extends TransactionalTestCase {
       master.getChildren().add(child);
     }
 
-    Ebean.save(master);
+    DB.save(master);
 
-    OrderMaster result = Ebean.find(OrderMaster.class).findOne();
+    OrderMaster result = DB.find(OrderMaster.class).findOne();
 
     assertThat(result.getChildren()).hasSize(5);
     assertThat(master.getChildren()).extracting(OrderReferencedChild::getName).containsExactly("p0", "p1", "p2", "p3", "p4");
@@ -53,9 +53,9 @@ public class TestOrderColumn extends TransactionalTestCase {
     master.getChildren().sort(Comparator.comparing(OrderReferencedChild::getName).reversed());
     assertThat(master.getChildren()).extracting(OrderReferencedChild::getName).containsExactly("p4", "p3", "p2", "p1", "p0");
 
-    Ebean.save(master);
+    DB.save(master);
 
-    result = Ebean.find(OrderMaster.class).findOne();
+    result = DB.find(OrderMaster.class).findOne();
 
     assertThat(result.getChildren()).hasSize(5);
     assertThat(result.getChildren()).extracting(OrderReferencedChild::getName).containsExactly("p4", "p3", "p2", "p1", "p0");
@@ -77,9 +77,9 @@ public class TestOrderColumn extends TransactionalTestCase {
       master.getChildren().add(child);
     }
 
-    Ebean.save(master);
+    DB.save(master);
 
-    final OrderMaster result = Ebean.find(OrderMaster.class).findOne();
+    final OrderMaster result = DB.find(OrderMaster.class).findOne();
 
     final List<OrderReferencedChild> children = result.getChildren();
     assertThat(children).hasSize(5);
@@ -97,9 +97,9 @@ public class TestOrderColumn extends TransactionalTestCase {
     children.get(1).getToys().get(0).setTitle("tt10");
     children.get(3).getToys().get(2).setTitle("tt32");
 
-    LoggedSqlCollector.start();
-    Ebean.save(result);
-    final List<String> sql = LoggedSqlCollector.current();
+    LoggedSql.start();
+    DB.save(result);
+    final List<String> sql = LoggedSql.collect();
     assertThat(sql).hasSize(3);
 
     assertThat(sql.get(0)).contains("update order_toy set title=?, sort_order=? where id=?");
@@ -123,9 +123,9 @@ public class TestOrderColumn extends TransactionalTestCase {
       master.getChildren().add(child);
     }
 
-    Ebean.save(master);
+    DB.save(master);
 
-    final OrderMaster result = Ebean.find(OrderMaster.class).findOne();
+    final OrderMaster result = DB.find(OrderMaster.class).findOne();
 
     final List<OrderReferencedChild> children = result.getChildren();
     assertThat(children).hasSize(5);
@@ -134,9 +134,9 @@ public class TestOrderColumn extends TransactionalTestCase {
 
     child.getToys().remove(1);
 
-    LoggedSqlCollector.start();
-    Ebean.save(result);
-    final List<String> sql = LoggedSqlCollector.stop();
+    LoggedSql.start();
+    DB.save(result);
+    final List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(4);
     assertSql(sql.get(0)).contains("delete from order_toy where id=?");
diff --git a/ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextOnUpdateDuringTxn.java b/ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextOnUpdateDuringTxn.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextOnUpdateDuringTxn.java
rename to ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextOnUpdateDuringTxn.java
index 93adb4e01..aa4971107 100644
--- a/ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextOnUpdateDuringTxn.java
+++ b/ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextOnUpdateDuringTxn.java
@@ -1,10 +1,10 @@
 package org.tests.persistencecontext;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -13,7 +13,7 @@ public class TestPersistenceContextOnUpdateDuringTxn extends BaseTestCase {
   @Test
   public void test() {
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     server.beginTransaction();
     try {
diff --git a/ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextQueryScope.java b/ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextQueryScope.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextQueryScope.java
rename to ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextQueryScope.java
index 6e80dc3d4..235976ee4 100644
--- a/ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextQueryScope.java
+++ b/ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextQueryScope.java
@@ -2,14 +2,13 @@ package org.tests.persistencecontext;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 
 import static io.ebean.PersistenceContextScope.QUERY;
 import static io.ebean.PersistenceContextScope.TRANSACTION;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
 
 
 public class TestPersistenceContextQueryScope extends BaseTestCase {
@@ -18,13 +17,13 @@ public class TestPersistenceContextQueryScope extends BaseTestCase {
   public void test() {
 
     EBasicVer bean = new EBasicVer("first");
-    Ebean.save(bean);
+    DB.save(bean);
 
-    //Ebean.getServerCacheManager().setCaching(EBasicVer.class, true);
+    //DB.cacheManager().setCaching(EBasicVer.class, true);
 
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
-      EBasicVer bean1 = Ebean.find(EBasicVer.class, bean.getId());
+      EBasicVer bean1 = DB.find(EBasicVer.class, bean.getId());
 
       // do an update of the name in the DB
       int rowCount = DB.sqlUpdate("update e_basicver set name=? where id=?")
@@ -36,21 +35,21 @@ public class TestPersistenceContextQueryScope extends BaseTestCase {
 
       // fetch the bean again... but doesn't hit DB as it
       // is in the PersistenceContext which is transaction scoped
-      EBasicVer bean2 = Ebean.find(EBasicVer.class)
+      EBasicVer bean2 = DB.find(EBasicVer.class)
         .setId(bean.getId())
         .setUseCache(false) // ignore L2 cache
         .findOne();
 
       // QUERY scope hits the DB (doesn't use the existing transactions persistence context)
       // ... also explicitly not use bean cache
-      EBasicVer bean3 = Ebean.find(EBasicVer.class)
+      EBasicVer bean3 = DB.find(EBasicVer.class)
         .setId(bean.getId())
         .setUseCache(false) // ignore L2 cache
         .setPersistenceContextScope(QUERY)
         .findOne();
 
       // TRANsACTION scope ... same as bean2 and does not hit the DB
-      EBasicVer bean5 = Ebean.find(EBasicVer.class)
+      EBasicVer bean5 = DB.find(EBasicVer.class)
         .setId(bean.getId())
         .setUseCache(false) // ignore L2 cache
         .setPersistenceContextScope(TRANSACTION)
@@ -64,12 +63,12 @@ public class TestPersistenceContextQueryScope extends BaseTestCase {
       assertSame(bean1, bean5);
 
       assertEquals("second", bean3.getName());
-      Ebean.delete(bean3);
+      DB.delete(bean3);
 
-      Ebean.commitTransaction();
+      DB.commitTransaction();
 
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextScopeUsingOrders.java b/ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextScopeUsingOrders.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextScopeUsingOrders.java
rename to ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextScopeUsingOrders.java
index 2db2125f9..81aed21f8 100644
--- a/ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextScopeUsingOrders.java
+++ b/ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextScopeUsingOrders.java
@@ -1,11 +1,11 @@
 package org.tests.persistencecontext;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -13,8 +13,8 @@ import java.util.List;
 import java.util.Set;
 
 import static io.ebean.PersistenceContextScope.QUERY;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestPersistenceContextScopeUsingOrders extends BaseTestCase {
 
@@ -23,7 +23,7 @@ public class TestPersistenceContextScopeUsingOrders extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Order> orders = Ebean.find(Order.class)
+    List<Order> orders = DB.find(Order.class)
       // Use QUERY or TRANSACTION scope (just not NONE)
       .setPersistenceContextScope(QUERY)
       .fetch("customer", "id, name")
diff --git a/ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextServerConfig.java b/ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextServerConfig.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextServerConfig.java
rename to ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextServerConfig.java
index 73175fb06..67fc1d549 100644
--- a/ebean-core/src/test/java/org/tests/persistencecontext/TestPersistenceContextServerConfig.java
+++ b/ebean-test/src/test/java/org/tests/persistencecontext/TestPersistenceContextServerConfig.java
@@ -1,20 +1,16 @@
 package org.tests.persistencecontext;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Database;
-import io.ebean.DatabaseFactory;
-import io.ebean.PersistenceContextScope;
-import io.ebean.Query;
+import io.ebean.*;
 import io.ebean.config.ContainerConfig;
 import io.ebean.config.DatabaseConfig;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.SpiQuery;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 
 import java.util.Properties;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestPersistenceContextServerConfig extends BaseTestCase {
 
@@ -23,7 +19,7 @@ public class TestPersistenceContextServerConfig extends BaseTestCase {
     SpiEbeanServer ebeanServer = (SpiEbeanServer) create();
     try {
       Query<EBasicVer> query = ebeanServer.find(EBasicVer.class);
-      PersistenceContextScope scope = ebeanServer.getPersistenceContextScope((SpiQuery<?>) query);
+      PersistenceContextScope scope = ebeanServer.persistenceContextScope((SpiQuery<?>) query);
 
       assertEquals(PersistenceContextScope.QUERY, scope);
     } finally {
diff --git a/ebean-core/src/test/java/org/tests/profile/ProfileLocationTest.java b/ebean-test/src/test/java/org/tests/profile/ProfileLocationTest.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/profile/ProfileLocationTest.java
rename to ebean-test/src/test/java/org/tests/profile/ProfileLocationTest.java
index c7b0edfe9..b89c5e448 100644
--- a/ebean-core/src/test/java/org/tests/profile/ProfileLocationTest.java
+++ b/ebean-test/src/test/java/org/tests/profile/ProfileLocationTest.java
@@ -1,7 +1,7 @@
 package org.tests.profile;
 
 import io.ebean.ProfileLocation;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/profile/ProfileSimpleQuery.java b/ebean-test/src/test/java/org/tests/profile/ProfileSimpleQuery.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/profile/ProfileSimpleQuery.java
rename to ebean-test/src/test/java/org/tests/profile/ProfileSimpleQuery.java
diff --git a/ebean-core/src/test/java/org/tests/query/TestAddOrderByWithFirstRowsMaxRows.java b/ebean-test/src/test/java/org/tests/query/TestAddOrderByWithFirstRowsMaxRows.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/query/TestAddOrderByWithFirstRowsMaxRows.java
rename to ebean-test/src/test/java/org/tests/query/TestAddOrderByWithFirstRowsMaxRows.java
index 1a7e708aa..c3c5fb7c0 100644
--- a/ebean-core/src/test/java/org/tests/query/TestAddOrderByWithFirstRowsMaxRows.java
+++ b/ebean-test/src/test/java/org/tests/query/TestAddOrderByWithFirstRowsMaxRows.java
@@ -1,10 +1,10 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.PagedList;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
@@ -22,14 +22,14 @@ public class TestAddOrderByWithFirstRowsMaxRows extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .setFirstRow(3)
       .order().asc("id")
       .findList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("order by t0.id");
@@ -41,13 +41,13 @@ public class TestAddOrderByWithFirstRowsMaxRows extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .setMaxRows(10)
       .findList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(1);
     if (isH2()) {
@@ -61,15 +61,15 @@ public class TestAddOrderByWithFirstRowsMaxRows extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .setFirstRow(3)
       .setMaxRows(10)
       .order().asc("id")
       .findList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("order by t0.id");
@@ -80,15 +80,15 @@ public class TestAddOrderByWithFirstRowsMaxRows extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // maxRows 1 with no first rows means Ebean does not automatically
     // add the order by id to the query
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .setMaxRows(1)
       .findList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).doesNotContain("order by t0.id");
@@ -99,16 +99,16 @@ public class TestAddOrderByWithFirstRowsMaxRows extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     PagedList<Order> pagedList =
-      Ebean.find(Order.class)
+      DB.find(Order.class)
         .setMaxRows(10)
         .findPagedList();
 
     pagedList.getList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(1);
     if (isH2()) {
@@ -121,16 +121,16 @@ public class TestAddOrderByWithFirstRowsMaxRows extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .setFirstRow(10)
       .setMaxRows(10)
       .order("id")
       .findPagedList()
       .getList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(1);
     if (isH2()) {
@@ -144,15 +144,15 @@ public class TestAddOrderByWithFirstRowsMaxRows extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .order().asc("orderDate")
       .setMaxRows(10)
       .findPagedList()
       .getList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("order by t0.order_date");
@@ -163,16 +163,16 @@ public class TestAddOrderByWithFirstRowsMaxRows extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .order().asc("orderDate")
       .order().desc("id")
       .setMaxRows(10)
       .findPagedList()
       .getList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("order by t0.order_date, t0.id desc");
diff --git a/ebean-core/src/test/java/org/tests/query/TestAutofetchTuneWithJoin.java b/ebean-test/src/test/java/org/tests/query/TestAutofetchTuneWithJoin.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/query/TestAutofetchTuneWithJoin.java
rename to ebean-test/src/test/java/org/tests/query/TestAutofetchTuneWithJoin.java
index 8d368a9c8..52a3dd791 100644
--- a/ebean-core/src/test/java/org/tests/query/TestAutofetchTuneWithJoin.java
+++ b/ebean-test/src/test/java/org/tests/query/TestAutofetchTuneWithJoin.java
@@ -1,21 +1,21 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.bean.ObjectGraphNode;
 import io.ebean.bean.ObjectGraphOrigin;
 import io.ebeaninternal.api.SpiQuery;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
 
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class TestAutofetchTuneWithJoin extends BaseTestCase {
 
   @Test
@@ -28,7 +28,7 @@ public class TestAutofetchTuneWithJoin extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> q = Ebean.find(Order.class)
+    Query<Order> q = DB.find(Order.class)
       .setAutoTune(true)
       //.fetch("customer")
       //.fetch("customer.contacts")
@@ -68,7 +68,7 @@ public class TestAutofetchTuneWithJoin extends BaseTestCase {
 
   private static void collectUsage() {
 
-    Ebean.getDefaultServer().getAutoTune().collectProfiling();
+    DB.getDefault().autoTune().collectProfiling();
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/query/TestConnectionCloseOnSqlerr.java b/ebean-test/src/test/java/org/tests/query/TestConnectionCloseOnSqlerr.java
similarity index 64%
rename from ebean-core/src/test/java/org/tests/query/TestConnectionCloseOnSqlerr.java
rename to ebean-test/src/test/java/org/tests/query/TestConnectionCloseOnSqlerr.java
index baddc58dc..d12e052ff 100644
--- a/ebean-core/src/test/java/org/tests/query/TestConnectionCloseOnSqlerr.java
+++ b/ebean-test/src/test/java/org/tests/query/TestConnectionCloseOnSqlerr.java
@@ -1,11 +1,12 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.fail;
 
 public class TestConnectionCloseOnSqlerr extends BaseTestCase {
 
@@ -21,13 +22,13 @@ public class TestConnectionCloseOnSqlerr extends BaseTestCase {
     try {
       for (int i = 0; i < 100; i++) {
         try {
-          Query<Customer> q0 = Ebean.find(Customer.class).where().icontains("namexxx", "Rob")
+          Query<Customer> q0 = DB.find(Customer.class).where().icontains("namexxx", "Rob")
             .query();
 
           q0.findList();
         } catch (Exception e) {
           if (e.getMessage().contains("Unsuccessfully waited")) {
-            Assert.fail("No connections found while only one thread is running. (after " + i + " queries)");
+            fail();
           } else {
             e.printStackTrace();
           }
@@ -49,22 +50,22 @@ public class TestConnectionCloseOnSqlerr extends BaseTestCase {
 
     try {
       for (int i = 0; i < 100; i++) {
-        Ebean.beginTransaction();
+        DB.beginTransaction();
         try {
-          Query<Customer> q0 = Ebean.find(Customer.class).where().icontains("namexxx", "Rob")
+          Query<Customer> q0 = DB.find(Customer.class).where().icontains("namexxx", "Rob")
             .query();
 
           q0.findList();
-          Ebean.commitTransaction();
+          DB.commitTransaction();
         } catch (Exception e) {
           if (e.getMessage().contains("Unsuccessfully waited")) {
-            Assert.fail("No connections found while only one thread is running. (after " + i + " queries)");
+            fail("No connections found while only one thread is running. (after " + i + " queries)");
           } else {
             e.printStackTrace();
           }
         } finally {
-          if (Ebean.currentTransaction().isActive()) {
-            Ebean.rollbackTransaction();
+          if (DB.currentTransaction().isActive()) {
+            DB.rollbackTransaction();
           }
         }
       }
diff --git a/ebean-test/src/test/java/org/tests/query/TestDefaultFetchLazy.java b/ebean-test/src/test/java/org/tests/query/TestDefaultFetchLazy.java
new file mode 100644
index 000000000..0328af33f
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/query/TestDefaultFetchLazy.java
@@ -0,0 +1,52 @@
+package org.tests.query;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.DB;
+import io.ebean.Query;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.MyLobSize;
+
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestDefaultFetchLazy extends BaseTestCase {
+
+  @Test
+  public void testFetchTypeLazy() {
+
+    MyLobSize m = new MyLobSize();
+    m.setName("aname");
+    m.setMyCount(10);
+    m.setMyLob("A big lob of data");
+
+    DB.save(m);
+
+    assertNotNull(m.getId());
+
+    MyLobSize myLobSize = DB.find(MyLobSize.class, m.getId());
+
+    BeanState beanState = DB.beanState(myLobSize);
+    Set<String> loadedProps = beanState.loadedProps();
+
+    assertNotNull(loadedProps);
+    assertTrue(loadedProps.contains("id"));
+    assertTrue(loadedProps.contains("name"));
+
+    // FetchType.LAZY properties excluded
+    assertFalse(loadedProps.contains("myLob"));
+    assertFalse(loadedProps.contains("myCount"));
+
+    // the details is also tuned
+    Query<MyLobSize> queryMany = DB.find(MyLobSize.class).fetch("details")// ,"+query")
+      .where().gt("id", 0).query();
+
+    queryMany.findList();
+
+    String generatedSql = queryMany.getGeneratedSql();
+    assertTrue(generatedSql.contains("t1.other"));
+    assertFalse(generatedSql.contains("t1.something"));
+  }
+
+}
diff --git a/ebean-core/src/test/java/org/tests/query/TestExprNestedDisjunction.java b/ebean-test/src/test/java/org/tests/query/TestExprNestedDisjunction.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/query/TestExprNestedDisjunction.java
rename to ebean-test/src/test/java/org/tests/query/TestExprNestedDisjunction.java
index cceeb63ae..ec5e64686 100644
--- a/ebean-core/src/test/java/org/tests/query/TestExprNestedDisjunction.java
+++ b/ebean-test/src/test/java/org/tests/query/TestExprNestedDisjunction.java
@@ -1,9 +1,9 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -18,7 +18,7 @@ public class TestExprNestedDisjunction extends BaseTestCase {
 
     java.sql.Date onAfter = java.sql.Date.valueOf("2009-08-31");
 
-    Query<Customer> q = Ebean.find(Customer.class).where()
+    Query<Customer> q = DB.find(Customer.class).where()
       .disjunction()
       .conjunction().startsWith("name", "r").eq("anniversary", onAfter).endJunction()
       .conjunction().eq("status", Customer.Status.ACTIVE).gt("id", 0).endJunction()
@@ -39,7 +39,7 @@ public class TestExprNestedDisjunction extends BaseTestCase {
 
     java.sql.Date onAfter = java.sql.Date.valueOf("2009-08-31");
 
-    Query<Customer> q = Ebean.find(Customer.class)
+    Query<Customer> q = DB.find(Customer.class)
       .where()
       .or()
       .and()
@@ -62,7 +62,7 @@ public class TestExprNestedDisjunction extends BaseTestCase {
 
     java.sql.Date onAfter = java.sql.Date.valueOf("2009-08-31");
 
-    Query<Customer> q = Ebean.find(Customer.class)
+    Query<Customer> q = DB.find(Customer.class)
       .where()
       .not()
       .gt("id", 1)
@@ -83,7 +83,7 @@ public class TestExprNestedDisjunction extends BaseTestCase {
 
     java.sql.Date onAfter = java.sql.Date.valueOf("2009-08-31");
 
-    Query<Customer> q = Ebean.find(Customer.class)
+    Query<Customer> q = DB.find(Customer.class)
       .where()
       .or()
       .eq("status", Customer.Status.ACTIVE)
@@ -105,7 +105,7 @@ public class TestExprNestedDisjunction extends BaseTestCase {
 
     java.sql.Date onAfter = java.sql.Date.valueOf("2009-08-31");
 
-    Query<Customer> q = Ebean.find(Customer.class)
+    Query<Customer> q = DB.find(Customer.class)
       .where()
       .or()
       .eq("status", Customer.Status.ACTIVE)
diff --git a/ebean-core/src/test/java/org/tests/query/TestFindOneOrEmpty.java b/ebean-test/src/test/java/org/tests/query/TestFindOneOrEmpty.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/query/TestFindOneOrEmpty.java
rename to ebean-test/src/test/java/org/tests/query/TestFindOneOrEmpty.java
index d9952c8c0..a03386c2e 100644
--- a/ebean-core/src/test/java/org/tests/query/TestFindOneOrEmpty.java
+++ b/ebean-test/src/test/java/org/tests/query/TestFindOneOrEmpty.java
@@ -1,8 +1,8 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -15,7 +15,7 @@ public class TestFindOneOrEmpty extends BaseTestCase {
   @Test
   public void empty() {
 
-    Optional<Customer> willBeEmpty = Ebean.find(Customer.class)
+    Optional<Customer> willBeEmpty = DB.find(Customer.class)
       .setId(Integer.MAX_VALUE)
       .findOneOrEmpty();
 
@@ -27,7 +27,7 @@ public class TestFindOneOrEmpty extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Optional<Customer> customer = Ebean.find(Customer.class)
+    Optional<Customer> customer = DB.find(Customer.class)
       .setId(1)
       .findOneOrEmpty();
 
diff --git a/ebean-core/src/test/java/org/tests/query/TestIContains.java b/ebean-test/src/test/java/org/tests/query/TestIContains.java
similarity index 53%
rename from ebean-core/src/test/java/org/tests/query/TestIContains.java
rename to ebean-test/src/test/java/org/tests/query/TestIContains.java
index 236e7895a..c014aace4 100644
--- a/ebean-core/src/test/java/org/tests/query/TestIContains.java
+++ b/ebean-test/src/test/java/org/tests/query/TestIContains.java
@@ -1,14 +1,10 @@
 package org.tests.query;
 
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -20,7 +16,7 @@ public class TestIContains extends BaseTestCase {
     ResetBasicData.reset();
 
     // case insensitive
-    Query<Customer> query = Ebean.find(Customer.class).where().icontains("name", "Rob").query();
+    Query<Customer> query = DB.find(Customer.class).where().icontains("name", "Rob").query();
 
     query.findList();
     String generatedSql = query.getGeneratedSql();
@@ -28,21 +24,21 @@ public class TestIContains extends BaseTestCase {
     assertThat(generatedSql).contains("lower(t0.name)");
 
     // case sensitive
-    query = Ebean.find(Customer.class).where().contains("name", "Rob").query();
+    query = DB.find(Customer.class).where().contains("name", "Rob").query();
 
     query.findList();
     generatedSql = query.getGeneratedSql();
 
     assertThat(generatedSql).contains(" t0.name ");
 
-    Ebean.find(Customer.class).where().icontains("name", "Rob").findList();
-    Ebean.find(Customer.class).where().icontains("name", "Rob").findList();
-    Ebean.find(Customer.class).where().icontains("name", "Rob").findList();
+    DB.find(Customer.class).where().icontains("name", "Rob").findList();
+    DB.find(Customer.class).where().icontains("name", "Rob").findList();
+    DB.find(Customer.class).where().icontains("name", "Rob").findList();
 
     String sql = "select id, status, name from o_customer where lower(name) like :name";
     RawSql parse = RawSqlBuilder.parse(sql).create();
 
-    Ebean.find(Customer.class).setRawSql(parse).setParameter("name", "Jim").findList();
+    DB.find(Customer.class).setRawSql(parse).setParameter("name", "Jim").findList();
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/query/TestImplicitJoinOnParentRelationship.java b/ebean-test/src/test/java/org/tests/query/TestImplicitJoinOnParentRelationship.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/query/TestImplicitJoinOnParentRelationship.java
rename to ebean-test/src/test/java/org/tests/query/TestImplicitJoinOnParentRelationship.java
index eac3303fb..fd73bdbb1 100644
--- a/ebean-core/src/test/java/org/tests/query/TestImplicitJoinOnParentRelationship.java
+++ b/ebean-test/src/test/java/org/tests/query/TestImplicitJoinOnParentRelationship.java
@@ -1,9 +1,9 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -16,7 +16,7 @@ public class TestImplicitJoinOnParentRelationship extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id, name")
       .where().eq("orders.details.product.name", "Desk")
       .query();
@@ -47,7 +47,7 @@ public class TestImplicitJoinOnParentRelationship extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id, name")
       .where().disjunction().eq("orders.details.product.name", "Desk").eq("id", 4).endJunction()
       .query();
@@ -68,7 +68,7 @@ public class TestImplicitJoinOnParentRelationship extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id, name")
       .where().or().eq("orders.details.product.name", "Desk").eq("id", 4).endJunction()
       .query();
diff --git a/ebean-core/src/test/java/org/tests/query/TestInvalidFetchPath.java b/ebean-test/src/test/java/org/tests/query/TestInvalidFetchPath.java
similarity index 51%
rename from ebean-core/src/test/java/org/tests/query/TestInvalidFetchPath.java
rename to ebean-test/src/test/java/org/tests/query/TestInvalidFetchPath.java
index 987dc058d..fd96088ba 100644
--- a/ebean-core/src/test/java/org/tests/query/TestInvalidFetchPath.java
+++ b/ebean-test/src/test/java/org/tests/query/TestInvalidFetchPath.java
@@ -1,34 +1,35 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
-import org.junit.Test;
 
 import javax.persistence.PersistenceException;
 
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 public class TestInvalidFetchPath extends BaseTestCase {
 
-  @Test(expected = PersistenceException.class)
+  @Test
   public void invalidFetchPathAndProperties_expect_error() {
-
-    Ebean.find(Customer.class)
-      .fetch("notValidPath", "notHaveProps")
-      .findList();
+    assertThrows(PersistenceException.class, () ->
+      DB.find(Customer.class)
+        .fetch("notValidPath", "notHaveProps")
+        .findList());
   }
 
-  @Test(expected = PersistenceException.class)
+  @Test
   public void invalidFetchPath_expect_error() {
-
-    Ebean.find(Customer.class)
-      .fetch("notValidPath")
-      .findList();
+    assertThrows(PersistenceException.class, () ->
+      DB.find(Customer.class)
+        .fetch("notValidPath")
+        .findList());
   }
 
   @Test
   public void fetchWithInvalidPropertyName_expect_allowed() {
-
-    Ebean.find(Customer.class)
+    DB.find(Customer.class)
       .fetch("billingAddress", "invalidPropertyName")
       .findList();
   }
diff --git a/ebean-core/src/test/java/org/tests/query/TestJoinOptOneCascade.java b/ebean-test/src/test/java/org/tests/query/TestJoinOptOneCascade.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/query/TestJoinOptOneCascade.java
rename to ebean-test/src/test/java/org/tests/query/TestJoinOptOneCascade.java
index 881117d75..2991df135 100644
--- a/ebean-core/src/test/java/org/tests/query/TestJoinOptOneCascade.java
+++ b/ebean-test/src/test/java/org/tests/query/TestJoinOptOneCascade.java
@@ -1,9 +1,9 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EOptOneA;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -14,7 +14,7 @@ public class TestJoinOptOneCascade extends BaseTestCase {
   public void test() {
 
     // the left join cascades to the join for c
-    Query<EOptOneA> query = Ebean.find(EOptOneA.class).fetch("b").fetch("b.c");
+    Query<EOptOneA> query = DB.find(EOptOneA.class).fetch("b").fetch("b.c");
 
     query.findList();
     String sql = query.getGeneratedSql();
@@ -28,7 +28,7 @@ public class TestJoinOptOneCascade extends BaseTestCase {
   public void test_where() {
 
     // the left join cascades to the join for c
-    Query<EOptOneA> query = Ebean.find(EOptOneA.class)
+    Query<EOptOneA> query = DB.find(EOptOneA.class)
       .where()
       .eq("b.c.nameForC", "foo")
       .query();
diff --git a/ebean-core/src/test/java/org/tests/query/TestLimitAlterFetchMany.java b/ebean-test/src/test/java/org/tests/query/TestLimitAlterFetchMany.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/query/TestLimitAlterFetchMany.java
rename to ebean-test/src/test/java/org/tests/query/TestLimitAlterFetchMany.java
index b5ac9abcc..80d7d6c0d 100644
--- a/ebean-core/src/test/java/org/tests/query/TestLimitAlterFetchMany.java
+++ b/ebean-test/src/test/java/org/tests/query/TestLimitAlterFetchMany.java
@@ -1,9 +1,9 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -21,7 +21,7 @@ public class TestLimitAlterFetchMany extends BaseTestCase {
     // ... otherwise we wouldn't be able to use the
     // limit offset clause
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       // this will automatically get converted to a
       // query join ... due to the maxRows
       .fetch("contacts").setMaxRows(5).order("id");
diff --git a/ebean-core/src/test/java/org/tests/query/TestLimitQuery.java b/ebean-test/src/test/java/org/tests/query/TestLimitQuery.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/query/TestLimitQuery.java
rename to ebean-test/src/test/java/org/tests/query/TestLimitQuery.java
index 4c9f9f3e5..52442979c 100644
--- a/ebean-core/src/test/java/org/tests/query/TestLimitQuery.java
+++ b/ebean-test/src/test/java/org/tests/query/TestLimitQuery.java
@@ -1,14 +1,15 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestLimitQuery extends BaseTestCase {
 
   @Test
@@ -16,7 +17,7 @@ public class TestLimitQuery extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> customers = Ebean.find(Customer.class)
+    List<Customer> customers = DB.find(Customer.class)
       .setAutoTune(false)
       .setFirstRow(0)
       .setMaxRows(10)
@@ -24,7 +25,7 @@ public class TestLimitQuery extends BaseTestCase {
       .findList();
 
     // should at least find the "Cust NoAddress" customer
-    Assert.assertTrue(!customers.isEmpty());
+    assertTrue(!customers.isEmpty());
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/query/TestManyWhereJoin.java b/ebean-test/src/test/java/org/tests/query/TestManyWhereJoin.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/query/TestManyWhereJoin.java
rename to ebean-test/src/test/java/org/tests/query/TestManyWhereJoin.java
index b90751c83..4fa4d5685 100644
--- a/ebean-core/src/test/java/org/tests/query/TestManyWhereJoin.java
+++ b/ebean-test/src/test/java/org/tests/query/TestManyWhereJoin.java
@@ -1,13 +1,13 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.Product;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -18,7 +18,7 @@ public class TestManyWhereJoin extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class).select("id,status")
+    Query<Customer> query = DB.find(Customer.class).select("id,status")
       // the where on a 'many' (like orders) requires an
       // additional join and distinct which is independent
       // of a fetch join (if there is a fetch join)
@@ -49,7 +49,7 @@ public class TestManyWhereJoin extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class).select("id,status")
+    Query<Customer> query = DB.find(Customer.class).select("id,status")
       .fetch("orders")
       // the where on a 'many' (like orders) requires an
       // additional join and distinct which is independent
@@ -87,7 +87,7 @@ public class TestManyWhereJoin extends BaseTestCase {
 
     Long productId = 1L;
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .where().eq("details.product.id", productId)
       .order("cretime asc").query();
 
@@ -118,9 +118,9 @@ public class TestManyWhereJoin extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Product product = Ebean.getReference(Product.class, 1L);
+    Product product = DB.reference(Product.class, 1L);
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       //.fetch("details")
       .where().eq("details.product", product)
       .order("cretime asc").query();
@@ -152,9 +152,9 @@ public class TestManyWhereJoin extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Product product = Ebean.getReference(Product.class, 1L);
+    Product product = DB.reference(Product.class, 1L);
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .fetch("details")
       .where().eq("details.product", product)
       .order("cretime asc").query();
diff --git a/ebean-core/src/test/java/org/tests/query/TestManyWhereJoinM2M.java b/ebean-test/src/test/java/org/tests/query/TestManyWhereJoinM2M.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/query/TestManyWhereJoinM2M.java
rename to ebean-test/src/test/java/org/tests/query/TestManyWhereJoinM2M.java
index f936e2442..3d6eb76cb 100644
--- a/ebean-core/src/test/java/org/tests/query/TestManyWhereJoinM2M.java
+++ b/ebean-test/src/test/java/org/tests/query/TestManyWhereJoinM2M.java
@@ -1,57 +1,57 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.Transaction;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MRole;
 import org.tests.model.basic.MUser;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestManyWhereJoinM2M extends BaseTestCase {
 
   @Test
   public void test() {
 
-    try (Transaction txn = Ebean.beginTransaction()) {
+    try (Transaction txn = DB.beginTransaction()) {
 
       MRole r1 = new MRole();
       r1.setRoleName("role1");
-      Ebean.save(r1);
+      DB.save(r1);
 
       MRole r2 = new MRole();
       r2.setRoleName("role2special");
-      Ebean.save(r2);
+      DB.save(r2);
 
       MRole r3 = new MRole();
       r3.setRoleName("role3");
-      Ebean.save(r3);
+      DB.save(r3);
 
       MUser u0 = new MUser();
       u0.setUserName("user0");
       u0.addRole(r1);
       u0.addRole(r2);
 
-      Ebean.save(u0);
+      DB.save(u0);
 
       MUser u1 = new MUser();
       u1.setUserName("user1");
       u1.addRole(r1);
 
-      Ebean.save(u1);
+      DB.save(u1);
 
       MUser u2 = new MUser();
       u2.setUserName("user2");
-      Ebean.save(u2);
+      DB.save(u2);
 
       txn.commit();
     }
-    Query<MUser> query = Ebean.find(MUser.class).fetch("roles")
+    Query<MUser> query = DB.find(MUser.class).fetch("roles")
       // the where on a 'many' (like orders) requires an
       // additional join and distinct which is independent
       // of a fetch join (if there is a fetch join)
@@ -60,10 +60,10 @@ public class TestManyWhereJoinM2M extends BaseTestCase {
     query.findList();
 
     String sql = query.getGeneratedSql();
-    Assert.assertTrue(sql.contains("select distinct"));
-    Assert.assertTrue(sql.contains("left join mrole "));
-    Assert.assertTrue(sql.contains("join mrole "));
-    Assert.assertTrue(sql.contains(".role_name = ?"));
+    assertTrue(sql.contains("select distinct"));
+    assertTrue(sql.contains("left join mrole "));
+    assertTrue(sql.contains("join mrole "));
+    assertTrue(sql.contains(".role_name = ?"));
 
     isEmpty();
     isNotEmpty();
@@ -71,7 +71,7 @@ public class TestManyWhereJoinM2M extends BaseTestCase {
 
   private void isEmpty() {
 
-    Query<MUser> query = Ebean.find(MUser.class)
+    Query<MUser> query = DB.find(MUser.class)
       .where().isEmpty("roles")
       .query();
 
@@ -83,7 +83,7 @@ public class TestManyWhereJoinM2M extends BaseTestCase {
 
   private void isNotEmpty() {
 
-    Query<MUser> query = Ebean.find(MUser.class)
+    Query<MUser> query = DB.find(MUser.class)
       .select("userName")
       .where().isNotEmpty("roles")
       .query();
diff --git a/ebean-core/src/test/java/org/tests/query/TestMyAdHocSqlSelect.java b/ebean-test/src/test/java/org/tests/query/TestMyAdHocSqlSelect.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/query/TestMyAdHocSqlSelect.java
rename to ebean-test/src/test/java/org/tests/query/TestMyAdHocSqlSelect.java
index 65f6efd1f..0b51c347d 100644
--- a/ebean-core/src/test/java/org/tests/query/TestMyAdHocSqlSelect.java
+++ b/ebean-test/src/test/java/org/tests/query/TestMyAdHocSqlSelect.java
@@ -1,16 +1,11 @@
 package org.tests.query;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MyAdHoc;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestMyAdHocSqlSelect extends BaseTestCase {
 
@@ -26,7 +21,7 @@ public class TestMyAdHocSqlSelect extends BaseTestCase {
       .columnMapping("order_id", "order.id")
       .create();
 
-    Query<MyAdHoc> query = Ebean.find(MyAdHoc.class)
+    Query<MyAdHoc> query = DB.find(MyAdHoc.class)
       .setRawSql(rawSql)
       .where().gt("order_id", 0)
       .having().gt("detailCount", 0)
@@ -49,7 +44,7 @@ public class TestMyAdHocSqlSelect extends BaseTestCase {
       .columnMapping("detail_count", "detailCount")
       .create();
 
-    Query<MyAdHoc> query = Ebean.find(MyAdHoc.class)
+    Query<MyAdHoc> query = DB.find(MyAdHoc.class)
       .setRawSql(rawSql)
       .where().gt("order_id", 0)
       .having().gt("detailCount", 0)
diff --git a/ebean-core/src/test/java/org/tests/query/TestOneToManyCorrectGrouping.java b/ebean-test/src/test/java/org/tests/query/TestOneToManyCorrectGrouping.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/query/TestOneToManyCorrectGrouping.java
rename to ebean-test/src/test/java/org/tests/query/TestOneToManyCorrectGrouping.java
index 69cb9383e..47db41e2c 100644
--- a/ebean-core/src/test/java/org/tests/query/TestOneToManyCorrectGrouping.java
+++ b/ebean-test/src/test/java/org/tests/query/TestOneToManyCorrectGrouping.java
@@ -1,16 +1,16 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestOneToManyCorrectGrouping extends BaseTestCase {
 
@@ -20,7 +20,7 @@ public class TestOneToManyCorrectGrouping extends BaseTestCase {
   public void test() {
 
     ResetBasicData.reset();
-    Query<Customer> customerQuery = Ebean.find(Customer.class)
+    Query<Customer> customerQuery = DB.find(Customer.class)
       .fetch("orders")
       .where().le("id", 2)
       .query();
diff --git a/ebean-core/src/test/java/org/tests/query/TestOuterJoin.java b/ebean-test/src/test/java/org/tests/query/TestOuterJoin.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/query/TestOuterJoin.java
rename to ebean-test/src/test/java/org/tests/query/TestOuterJoin.java
index 61b7ffd25..d1834ddc0 100644
--- a/ebean-core/src/test/java/org/tests/query/TestOuterJoin.java
+++ b/ebean-test/src/test/java/org/tests/query/TestOuterJoin.java
@@ -1,10 +1,10 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebeantest.LoggedSql;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
@@ -21,17 +21,16 @@ import static org.assertj.core.api.Assertions.assertThat;
  */
 public class TestOuterJoin extends BaseTestCase {
 
-  @BeforeClass
+  @BeforeAll
   public static void setup() {
     ResetBasicData.reset();
   }
 
-
   @Test
   public void testOuterOnNullQuery() throws Exception {
 
     LoggedSql.start();
-    List<Customer> list = Ebean.find(Customer.class).where()
+    List<Customer> list = DB.find(Customer.class).where()
         .isNull("orders")
         .le("id", 4) // ignore others than basicData
         .findList();
@@ -42,7 +41,7 @@ public class TestOuterJoin extends BaseTestCase {
 
     // use OR construct
     LoggedSql.start();
-    list = Ebean.find(Customer.class).where()
+    list = DB.find(Customer.class).where()
         .or()
           .isNull("orders.details.product.name")
           .isNull("orders")
@@ -60,7 +59,7 @@ public class TestOuterJoin extends BaseTestCase {
 
     // use AND construct
     LoggedSql.start();
-    list = Ebean.find(Customer.class).where()
+    list = DB.find(Customer.class).where()
         .and()
           .isNull("orders.details.product.name")
           .isNull("orders")
@@ -77,7 +76,7 @@ public class TestOuterJoin extends BaseTestCase {
     assertThat(list).hasSize(2);
 
     LoggedSql.start();
-    list = Ebean.find(Customer.class).where()
+    list = DB.find(Customer.class).where()
         .isNull("orders.details.product.name")
         .le("id", 4) // ignore others than basicData
         .findList();
@@ -94,7 +93,7 @@ public class TestOuterJoin extends BaseTestCase {
   public void testInnerOnNonNullQuery() throws Exception {
 
     LoggedSql.start();
-    List<Customer> list = Ebean.find(Customer.class).where()
+    List<Customer> list = DB.find(Customer.class).where()
         .isNotNull("orders")
         .le("id", 4) // ignore others than basicData
         .findList();
@@ -105,7 +104,7 @@ public class TestOuterJoin extends BaseTestCase {
 
     // use OR construct
     LoggedSql.start();
-    list = Ebean.find(Customer.class).where()
+    list = DB.find(Customer.class).where()
         .or()
           .isNotNull("orders.details.product.name")
           .isNotNull("orders")
@@ -123,7 +122,7 @@ public class TestOuterJoin extends BaseTestCase {
 
     // use AND construct
     LoggedSql.start();
-    list = Ebean.find(Customer.class).where()
+    list = DB.find(Customer.class).where()
         .and()
           .isNotNull("orders.details.product.name")
           .isNotNull("orders")
@@ -139,7 +138,7 @@ public class TestOuterJoin extends BaseTestCase {
 
 
     LoggedSql.start();
-    list = Ebean.find(Customer.class).where()
+    list = DB.find(Customer.class).where()
         .isNotNull("orders.details.product.name")
         .le("id", 4) // ignore others than basicData
         .findList();
@@ -155,7 +154,7 @@ public class TestOuterJoin extends BaseTestCase {
 
     LoggedSql.start();
 
-    List<Order> orders1 =  Ebean.find(Order.class).order("id").findList();
+    List<Order> orders1 =  DB.find(Order.class).order("id").findList();
 
     assertThat(LoggedSql.collect().get(0))
       .contains(" join o_customer") // ensure that we do not left join the customer
@@ -165,7 +164,7 @@ public class TestOuterJoin extends BaseTestCase {
     // now fetch "details" bean, which may be optional
     LoggedSql.start();
 
-    List<Order> orders2 =  Ebean.find(Order.class)
+    List<Order> orders2 =  DB.find(Order.class)
         .fetch("details", "id").order("id").findList();
 
     assertThat(LoggedSql.collect().get(0))
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryAlias.java b/ebean-test/src/test/java/org/tests/query/TestQueryAlias.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/query/TestQueryAlias.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryAlias.java
index 4e77d49d6..d3df77f11 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryAlias.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryAlias.java
@@ -3,7 +3,7 @@ package org.tests.query;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.CKeyParent;
 import org.tests.model.basic.ResetBasicData;
 
@@ -36,7 +36,7 @@ public class TestQueryAlias extends BaseTestCase {
     assertThat(sql).contains("ckey_parent myt0");
     assertThat(sql).contains("(myt0.one_key) in (select st0.one_key from ckey_parent st0)");
   }
-  
+
   @Test
   public void testExistsWithConcat() {
 
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryBaseTable.java b/ebean-test/src/test/java/org/tests/query/TestQueryBaseTable.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/query/TestQueryBaseTable.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryBaseTable.java
index 22caeeace..2f5a32b28 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryBaseTable.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryBaseTable.java
@@ -1,11 +1,11 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -21,18 +21,18 @@ public class TestQueryBaseTable extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Customer one = Ebean.find(Customer.class)
+    Customer one = DB.find(Customer.class)
       .setBaseTable("O_CUSTOMER")
       .where().startsWith("name", "Rob")
       .findOne();
 
-    Customer two = Ebean.find(Customer.class)
+    Customer two = DB.find(Customer.class)
       .where().startsWith("name", "Rob")
       .findOne();
 
-    Customer three = Ebean.find(Customer.class)
+    Customer three = DB.find(Customer.class)
       .setBaseTable("O_CUSTOMER")
       .where().startsWith("name", "Fiona")
       .findOne();
@@ -40,7 +40,7 @@ public class TestQueryBaseTable extends BaseTestCase {
     assertThat(one.getName()).isEqualTo(two.getName());
     assertThat(three.getName()).isEqualTo("Fiona");
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("from O_CUSTOMER");
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryExists.java b/ebean-test/src/test/java/org/tests/query/TestQueryExists.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/query/TestQueryExists.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryExists.java
index 6034e16ab..e52212207 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryExists.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryExists.java
@@ -3,8 +3,8 @@ package org.tests.query;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
-import io.ebeantest.LoggedSql;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFetchJoinWithOrder.java b/ebean-test/src/test/java/org/tests/query/TestQueryFetchJoinWithOrder.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFetchJoinWithOrder.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFetchJoinWithOrder.java
index 68a382e5c..bec162c9a 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFetchJoinWithOrder.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFetchJoinWithOrder.java
@@ -1,16 +1,16 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestQueryFetchJoinWithOrder extends BaseTestCase {
 
   @Test
@@ -18,29 +18,29 @@ public class TestQueryFetchJoinWithOrder extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Order> list = Ebean.find(Order.class)
+    List<Order> list = DB.find(Order.class)
       .fetchQuery("details")
       .order().asc("id")
       .order().desc("details.id").findList();
 
-    Assert.assertNotNull(list);
+    assertNotNull(list);
 
-    List<Order> list2 = Ebean.find(Order.class)
+    List<Order> list2 = DB.find(Order.class)
       .fetchQuery("customer")
       .fetch("customer.contacts")
       .order().asc("id")
       .order().asc("customer.contacts.lastName")
       .findList();
 
-    Assert.assertNotNull(list2);
+    assertNotNull(list2);
 
-    List<Customer> list3 = Ebean.find(Customer.class)
+    List<Customer> list3 = DB.find(Customer.class)
       .fetch("orders")
       .filterMany("orders").eq("status", Order.Status.NEW)
       .order().desc("orders.id")
       .findList();
 
-    Assert.assertNotNull(list3);
+    assertNotNull(list3);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFetchManyTwoDeep.java b/ebean-test/src/test/java/org/tests/query/TestQueryFetchManyTwoDeep.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFetchManyTwoDeep.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFetchManyTwoDeep.java
index 048a6e97c..aa1592787 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFetchManyTwoDeep.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFetchManyTwoDeep.java
@@ -1,20 +1,20 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.OrderShipment;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestQueryFetchManyTwoDeep extends BaseTestCase {
 
@@ -24,19 +24,19 @@ public class TestQueryFetchManyTwoDeep extends BaseTestCase {
     ResetBasicData.reset();
 
     // test that join to order.details is not included in the initial query (included in query join)
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .setAutoTune(false)
       .fetch("orders")
       .fetch("orders.details");
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Customer> list = query.findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
-    assertTrue("has rows", !list.isEmpty());
+    assertTrue(!list.isEmpty());
     String mainSql = sqlOf(query);
     assertThat(mainSql).contains("from o_customer t0 ");
     assertThat(mainSql).contains("left join o_order t1 on t1.kcustomer_id = t0.id");
@@ -72,13 +72,13 @@ public class TestQueryFetchManyTwoDeep extends BaseTestCase {
     ResetBasicData.reset();
 
     // test that join to order.details is not included
-    Query<OrderShipment> shipQuery = Ebean.find(OrderShipment.class)
+    Query<OrderShipment> shipQuery = DB.find(OrderShipment.class)
       .setAutoTune(false)
       .fetch("order")
       .fetch("order.details");
 
     List<OrderShipment> shipList = shipQuery.findList();
-    assertTrue("has rows", !shipList.isEmpty());
+    assertTrue(!shipList.isEmpty());
 
     String generatedSql = shipQuery.getGeneratedSql();
 
@@ -113,13 +113,13 @@ public class TestQueryFetchManyTwoDeep extends BaseTestCase {
     ResetBasicData.reset();
 
     // test that join to order.details is not included
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .setAutoTune(false)
       .fetch("customer")
       .fetch("customer.orders");
 
     List<Contact> shipList = query.findList();
-    assertTrue("has rows", !shipList.isEmpty());
+    assertTrue(!shipList.isEmpty());
 
     String generatedSql = query.getGeneratedSql();
 
@@ -144,14 +144,14 @@ public class TestQueryFetchManyTwoDeep extends BaseTestCase {
     ResetBasicData.reset();
 
     // test that join to order.details is not included
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .setAutoTune(false)
       .fetch("customer")
       .where().ilike("customer.name", "Rob%")
       .query();
 
     List<Contact> list = query.findList();
-    assertTrue("has rows", !list.isEmpty());
+    assertTrue(!list.isEmpty());
 
     String generatedSql = query.getGeneratedSql();
 
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFetchSkipPath.java b/ebean-test/src/test/java/org/tests/query/TestQueryFetchSkipPath.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFetchSkipPath.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFetchSkipPath.java
index 196b56fa4..cf840ba25 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFetchSkipPath.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFetchSkipPath.java
@@ -1,13 +1,9 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.tests.model.basic.Contact;
-import org.tests.model.basic.ContactNote;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 
@@ -18,7 +14,7 @@ public class TestQueryFetchSkipPath extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Order> list = Ebean.find(Order.class)
+    List<Order> list = DB.find(Order.class)
 
       // .setAutoTune(true)
       .setAutoTune(false).select("status")
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFilterCaseInsensitive.java b/ebean-test/src/test/java/org/tests/query/TestQueryFilterCaseInsensitive.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFilterCaseInsensitive.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFilterCaseInsensitive.java
index 86a71b324..c7ac0311f 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFilterCaseInsensitive.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFilterCaseInsensitive.java
@@ -2,8 +2,8 @@ package org.tests.query;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -13,7 +13,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestQueryFilterCaseInsensitive extends BaseTestCase {
 
-  @BeforeClass
+  @BeforeAll
   public static void setup() {
     ResetBasicData.reset();
   }
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFilterMany.java b/ebean-test/src/test/java/org/tests/query/TestQueryFilterMany.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFilterMany.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFilterMany.java
index 92c334ed0..967efb9ba 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFilterMany.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFilterMany.java
@@ -4,8 +4,8 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.ExpressionList;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
@@ -15,7 +15,7 @@ import java.util.List;
 import java.util.Optional;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestQueryFilterMany extends BaseTestCase {
 
@@ -24,7 +24,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Customer customer = DB.find(Customer.class)
       .fetchLazy("orders")
@@ -36,7 +36,7 @@ public class TestQueryFilterMany extends BaseTestCase {
     final int size = customer.getOrders().size();
     assertThat(size).isGreaterThan(0);
 
-    List<String> sqlList = LoggedSqlCollector.stop();
+    List<String> sqlList = LoggedSql.stop();
     assertEquals(2, sqlList.size());
     assertThat(sqlList.get(1)).contains("status = ?");
 
@@ -50,7 +50,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     final Query<Customer> query = DB.find(Customer.class)
       .where().ieq("name", "Rob")
@@ -60,7 +60,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     final List<Customer> customers = query.findList();
     assertThat(customers).isNotEmpty();
-    List<String> sqlList = LoggedSqlCollector.stop();
+    List<String> sqlList = LoggedSql.stop();
     assertEquals(2, sqlList.size());
     assertThat(sqlList.get(0)).contains("lower(t0.name) = ?");
     assertThat(sqlList.get(1)).contains("status = ?");
@@ -78,7 +78,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     final Query<Customer> query = DB.find(Customer.class)
       .where().ieq("name", "Rob")
@@ -91,7 +91,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     final List<Customer> customers = query.findList();
     assertThat(customers).isNotEmpty();
-    List<String> sqlList = LoggedSqlCollector.stop();
+    List<String> sqlList = LoggedSql.stop();
     assertEquals(2, sqlList.size());
 
     assertThat(sqlList.get(0)).contains("lower(t0.name) = ?");
@@ -110,7 +110,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     final Query<Customer> query = DB.find(Customer.class)
       .where().ieq("name", "Rob")
@@ -121,7 +121,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     final List<Customer> customers = query.findList();
     assertThat(customers).isNotEmpty();
-    List<String> sqlList = LoggedSqlCollector.stop();
+    List<String> sqlList = LoggedSql.stop();
     assertEquals(2, sqlList.size());
     assertThat(sqlList.get(0)).contains("lower(t0.name) = ?");
     assertThat(sqlList.get(1)).contains("status = ?");
@@ -168,7 +168,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Query<Customer> query = DB.find(Customer.class)
       .filterMany("orders").raw("1=0")
@@ -180,7 +180,7 @@ public class TestQueryFilterMany extends BaseTestCase {
       assertThat(customer.getOrders()).isEmpty();
     }
 
-    List<String> sqlList = LoggedSqlCollector.stop();
+    List<String> sqlList = LoggedSql.stop();
     assertEquals(1, sqlList.size());
     assertThat(sqlList.get(0)).contains("from o_customer t0 left join o_order t1 on t1.kcustomer_id = t0.id and t1.order_date is not null left join o_customer t2 on t2.id = t1.kcustomer_id where exists (select 1 from o_order x where x.kcustomer_id = t0.id and x.order_date is not null) and 1=0 order by t0.id");
   }
@@ -190,7 +190,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Query<Customer> query = DB.find(Customer.class)
       .fetch("orders")
@@ -199,7 +199,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     query.findCount();
 
-    List<String> sqlList = LoggedSqlCollector.stop();
+    List<String> sqlList = LoggedSql.stop();
     assertEquals(1, sqlList.size());
     assertThat(sqlList.get(0)).contains("select count(*) from o_customer");
   }
@@ -208,7 +208,7 @@ public class TestQueryFilterMany extends BaseTestCase {
   public void test_filterMany_copy_findList() {
 
     ResetBasicData.reset();
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Query<Customer> query = DB.find(Customer.class)
       .fetch("orders")
@@ -217,7 +217,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     query.copy().findList();
 
-    List<String> sqlList = LoggedSqlCollector.stop();
+    List<String> sqlList = LoggedSql.stop();
     assertEquals(1, sqlList.size());
     assertThat(sqlList.get(0)).contains("from o_customer t0 left join o_order t1 on t1.kcustomer_id = t0.id and t1.order_date is not null left join o_customer t2 on t2.id = t1.kcustomer_id where t1.status ");
     if (isPostgres()) {
@@ -231,7 +231,7 @@ public class TestQueryFilterMany extends BaseTestCase {
   public void test_filterMany_fetchQuery() {
 
     ResetBasicData.reset();
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Query<Customer> query = DB.find(Customer.class)
       .fetchQuery("orders") // explicitly fetch orders separately
@@ -240,7 +240,7 @@ public class TestQueryFilterMany extends BaseTestCase {
 
     query.findList();
 
-    List<String> sqlList = LoggedSqlCollector.stop();
+    List<String> sqlList = LoggedSql.stop();
     assertEquals(2, sqlList.size());
     assertThat(sqlList.get(0)).contains("from o_customer t0");
     if (isPostgres()) {
@@ -256,7 +256,7 @@ public class TestQueryFilterMany extends BaseTestCase {
   public void testDisjunction() {
 
     ResetBasicData.reset();
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.find(Customer.class)
       .filterMany("orders")
@@ -265,7 +265,7 @@ public class TestQueryFilterMany extends BaseTestCase {
       .eq("orderDate", LocalDate.now())
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertEquals(1, sql.size());
     assertSql(sql.get(0)).contains(" from o_customer t0 left join o_order t1 on t1.kcustomer_id = t0.id and t1.order_date is not null left join o_customer t2 on t2.id = t1.kcustomer_id where (t1.status = ? or t1.order_date = ?) order by t0.id");
   }
@@ -274,13 +274,13 @@ public class TestQueryFilterMany extends BaseTestCase {
   public void testNestedFilterMany() {
 
     ResetBasicData.reset();
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.find(Customer.class)
       .filterMany("contacts").isNotNull("firstName")
       .filterMany("contacts.notes").istartsWith("title", "foo")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains(" from o_customer t0 left join contact t1 on t1.customer_id = t0.id where t1.first_name is not null order by t0.id; --bind()");
@@ -292,16 +292,20 @@ public class TestQueryFilterMany extends BaseTestCase {
   public void testFilterManyUsingExpression() {
 
     ResetBasicData.reset();
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.find(Customer.class)
       .where()
       .filterMany("contacts", "firstName isNotNull and email istartsWith ?", "rob")
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(1);
-    assertSql(sql.get(0)).contains(" from o_customer t0 left join contact t1 on t1.customer_id = t0.id where (t1.first_name is not null and lower(t1.email) like ? escape'|' ) order by t0.id; --bind(rob%)");
+    if (isSqlServer()) {
+      assertSql(sql.get(0)).contains(" from o_customer t0 left join contact t1 on t1.customer_id = t0.id where (t1.first_name is not null and lower(t1.email) like ? ) order by t0.id; --bind(rob%)");
+    } else {
+      assertSql(sql.get(0)).contains(" from o_customer t0 left join contact t1 on t1.customer_id = t0.id where (t1.first_name is not null and lower(t1.email) like ? escape'|' ) order by t0.id; --bind(rob%)");
+    }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFilterManyOnM2M.java b/ebean-test/src/test/java/org/tests/query/TestQueryFilterManyOnM2M.java
similarity index 56%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFilterManyOnM2M.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFilterManyOnM2M.java
index 02cc7c9e2..f47d9da52 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFilterManyOnM2M.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFilterManyOnM2M.java
@@ -1,16 +1,16 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MUser;
-import org.junit.Test;
 
 public class TestQueryFilterManyOnM2M extends BaseTestCase {
 
   @Test
   public void test() {
 
-    Ebean.find(MUser.class).fetch("roles").filterMany("roles").ilike("roleName", "Jim%").findList();
+    DB.find(MUser.class).fetch("roles").filterMany("roles").ilike("roleName", "Jim%").findList();
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFilterManyOnSecondary.java b/ebean-test/src/test/java/org/tests/query/TestQueryFilterManyOnSecondary.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFilterManyOnSecondary.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFilterManyOnSecondary.java
index f87c4c9c9..de9b567df 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFilterManyOnSecondary.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFilterManyOnSecondary.java
@@ -1,19 +1,16 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.OrderDetail;
-import org.tests.model.basic.Product;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestQueryFilterManyOnSecondary extends BaseTestCase {
 
   @Test
@@ -21,7 +18,7 @@ public class TestQueryFilterManyOnSecondary extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .fetchQuery("orders")
       .where().ilike("name", "Rob%").gt("id", 0)
       .filterMany("orders").eq("status", Order.Status.NEW)
@@ -31,7 +28,7 @@ public class TestQueryFilterManyOnSecondary extends BaseTestCase {
     for (Customer customer : list) {
       List<Order> orders = customer.getOrders();
       for (Order order : orders) {
-        Assert.assertEquals(Order.Status.NEW, order.getStatus());
+        assertEquals(Order.Status.NEW, order.getStatus());
       }
     }
 
@@ -43,7 +40,7 @@ public class TestQueryFilterManyOnSecondary extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .fetchQuery("details")
       .fetch("details.product", "name")
       .filterMany("details").ilike("product.name", "c%")
@@ -55,7 +52,7 @@ public class TestQueryFilterManyOnSecondary extends BaseTestCase {
       for (OrderDetail orderDetail : details) {
         Product product = orderDetail.getProduct();
         String name = product.getName();
-        Assert.assertTrue(name.startsWith("C"));
+        assertTrue(name.startsWith("C"));
       }
     }
   }
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFilterManySimple.java b/ebean-test/src/test/java/org/tests/query/TestQueryFilterManySimple.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFilterManySimple.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFilterManySimple.java
index 7dae5d580..7864838ff 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFilterManySimple.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFilterManySimple.java
@@ -1,12 +1,11 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.sql.Date;
 import java.util.List;
@@ -21,8 +20,7 @@ public class TestQueryFilterManySimple extends BaseTestCase {
     // not really last week :)
     Date lastWeek = Date.valueOf("2010-01-01");
 
-    List<Customer> list = Ebean
-      .find(Customer.class)
+    List<Customer> list = DB.find(Customer.class)
       // .join("orders", new JoinConfig().lazy())
       // .join("orders", new JoinConfig().query())
       .fetch("orders").fetchQuery("contacts").where().ilike("name", "rob%")
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFindEach.java b/ebean-test/src/test/java/org/tests/query/TestQueryFindEach.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFindEach.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFindEach.java
index b37f67279..9dce80a77 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFindEach.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFindEach.java
@@ -6,9 +6,9 @@ import io.ebean.Query;
 import io.ebean.Transaction;
 import io.ebean.annotation.Transactional;
 import io.ebean.bean.PersistenceContext;
+import io.ebean.test.LoggedSql;
 import io.ebeaninternal.api.SpiTransaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Contact;
@@ -23,7 +23,7 @@ import java.util.Random;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryFindEach extends BaseTestCase {
 
@@ -59,7 +59,7 @@ public class TestQueryFindEach extends BaseTestCase {
 
   private void seedData() {
     for (int i = 0; i < 15; i++) {
-      EBasicLog log = new EBasicLog("findEachBatch "+i);
+      EBasicLog log = new EBasicLog("findEachBatch " + i);
       DB.save(log);
     }
   }
@@ -101,7 +101,7 @@ public class TestQueryFindEach extends BaseTestCase {
 
   private void findEachWithBatch(int batchSize) {
     DB.find(EBasicLog.class)
-      .where().startsWith("name","findEachBatch")
+      .where().startsWith("name", "findEachBatch")
       .findEach(batchSize, batch -> {
         int batchId = batchCount.incrementAndGet();
         int rows = rowCount.addAndGet(batch.size());
@@ -126,13 +126,13 @@ public class TestQueryFindEach extends BaseTestCase {
       PersistenceContext pc = spiTxn.getPersistenceContext();
       assertThat(pc.size(Customer.class)).isEqualTo(customerList.size());
 
-      LoggedSqlCollector.start();
+      LoggedSql.start();
       query.findEach(contact -> {
         // use customer from persistence context (otherwise would invoke lazy loading)
         assertNotNull(contact.getCustomer().getName());
       });
 
-      final List<String> sql = LoggedSqlCollector.stop();
+      final List<String> sql = LoggedSql.stop();
       assertThat(sql).hasSize(1);
     }
   }
@@ -140,9 +140,8 @@ public class TestQueryFindEach extends BaseTestCase {
   /**
    * Test the behaviour when an exception is thrown inside the findVisit().
    */
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void testVisitThrowingException() {
-
     ResetBasicData.reset();
 
     Query<Customer> query = DB.find(Customer.class)
@@ -152,14 +151,13 @@ public class TestQueryFindEach extends BaseTestCase {
 
     final AtomicInteger counter = new AtomicInteger(0);
 
-    query.findEach(customer -> {
-      counter.incrementAndGet();
-      if (counter.intValue() > 0) {
-        throw new IllegalStateException("cause a failure");
-      }
-    });
-
-    fail("Never get here - exception thrown");
+    assertThrows(IllegalStateException.class, () ->
+      query.findEach(customer -> {
+        counter.incrementAndGet();
+        if (counter.intValue() > 0) {
+          throw new IllegalStateException("cause a failure");
+        }
+      }));
   }
 
   @Test
@@ -171,7 +169,7 @@ public class TestQueryFindEach extends BaseTestCase {
 
     test_setLazyLoadBatchSize_withFetchLazy();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.find(OmBasicChild.class)
       .setLazyLoadBatchSize(100)
@@ -179,13 +177,13 @@ public class TestQueryFindEach extends BaseTestCase {
         assertNotNull(child.getParent().getName());
       });
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql.size()).isLessThan(50);
   }
 
   private void test_setLazyLoadBatchSize_withFetchLazy() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.find(OmBasicParent.class)
       .setLazyLoadBatchSize(5)
@@ -195,7 +193,7 @@ public class TestQueryFindEach extends BaseTestCase {
         it.getChildren().size();
       });
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(11);
     assertThat(sql.get(0)).contains(" from om_basic_parent ");
     for (int i = 1; i < 11; i++) {
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFindEachWhile.java b/ebean-test/src/test/java/org/tests/query/TestQueryFindEachWhile.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFindEachWhile.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFindEachWhile.java
index 2588edf56..d444d54e0 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFindEachWhile.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFindEachWhile.java
@@ -2,17 +2,14 @@ package org.tests.query;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.FetchConfig;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryFindEachWhile extends BaseTestCase {
 
@@ -41,9 +38,8 @@ public class TestQueryFindEachWhile extends BaseTestCase {
   /**
    * Test the behaviour when an exception is thrown inside the findVisit().
    */
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void testVisitThrowingException() {
-
     ResetBasicData.reset();
 
     Query<Customer> query = DB.find(Customer.class).setAutoTune(false)
@@ -52,14 +48,14 @@ public class TestQueryFindEachWhile extends BaseTestCase {
 
     final AtomicInteger counter = new AtomicInteger(0);
 
-    query.findEachWhile(customer -> {
-      counter.incrementAndGet();
-      if (counter.intValue() > 0) {
-        throw new IllegalStateException("cause a failure");
-      }
-      return true;
-    });
-
-    fail("Never get here - exception thrown");
+    assertThrows(IllegalStateException.class, () -> {
+        query.findEachWhile(customer -> {
+          counter.incrementAndGet();
+          if (counter.intValue() > 0) {
+            throw new IllegalStateException("cause a failure");
+          }
+          return true;
+        });
+      });
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFindFutureList.java b/ebean-test/src/test/java/org/tests/query/TestQueryFindFutureList.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFindFutureList.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFindFutureList.java
index 074603e41..2a05cb16d 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFindFutureList.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFindFutureList.java
@@ -4,15 +4,15 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.FutureList;
 import io.ebean.Transaction;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestQueryFindFutureList extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFindIterate.java b/ebean-test/src/test/java/org/tests/query/TestQueryFindIterate.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFindIterate.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFindIterate.java
index 4dea23698..fa884feb2 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFindIterate.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFindIterate.java
@@ -4,10 +4,12 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.QueryIterator;
+import io.ebean.annotation.ForPlatform;
+import io.ebean.annotation.Platform;
 import io.ebean.datasource.DataSourcePool;
 import io.ebean.plugin.SpiServer;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderShipment;
@@ -19,10 +21,7 @@ import java.util.NoSuchElementException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryFindIterate extends BaseTestCase {
 
@@ -120,7 +119,7 @@ public class TestQueryFindIterate extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.find(Order.class)
       .setLazyLoadBatchSize(10)
@@ -136,7 +135,7 @@ public class TestQueryFindIterate extends BaseTestCase {
       });
 
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertEquals(3, loggedSql.size());
     assertTrue(trimSql(loggedSql.get(0), 7).contains("select t0.id, t0.status, t0.order_date, t1.id, t1.name from o_order t0 join o_customer t1"));
@@ -149,11 +148,11 @@ public class TestQueryFindIterate extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // make sure we don't hit the L2 cache for order shipments
-    DB.getServerCacheManager().clear(Order.class);
-    DB.getServerCacheManager().clear(OrderShipment.class);
+    DB.cacheManager().clear(Order.class);
+    DB.cacheManager().clear(OrderShipment.class);
 
     DB.find(Order.class)
       .setLazyLoadBatchSize(10)
@@ -171,16 +170,16 @@ public class TestQueryFindIterate extends BaseTestCase {
         order.getShipments().size();
       });
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
-    assertEquals("Got SQL: " + loggedSql, 2, loggedSql.size());
+    assertEquals(2, loggedSql.size());
     assertThat(trimSql(loggedSql.get(0), 7).contains("select t0.id, t0.status, t0.order_date, t1.id, t1.name, t2.id, t2.order_qty, t2.ship_qty"));
     assertThat(trimSql(loggedSql.get(1), 7).contains("select t0.order_id, t0.id, t0.ship_time, t0.cretime, t0.updtime, t0.version, t0.order_id from or_order_ship"));
   }
 
-  @Test(expected = PersistenceException.class)
+  @ForPlatform(Platform.H2)
+  @Test
   public void testWithExceptionInQuery() {
-
     ResetBasicData.reset();
 
     // intentionally a query with incorrect type binding
@@ -190,21 +189,11 @@ public class TestQueryFindIterate extends BaseTestCase {
       .setMaxRows(2).query();
 
     // this throws an exception immediately
-    query.findEach(bean -> {
-
-    });
-
-    if (!DB.getDefault().getName().equals("h2")) {
-      // MySql allows the query with type conversion?
-      throw new PersistenceException("H2 does expected thing but MySql does not");
-    }
-    fail("Never get here as exception thrown");
+    assertThrows(PersistenceException.class, () -> query.findEach(bean -> { }));
   }
 
-
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void testWithExceptionInLoop() {
-
     ResetBasicData.reset();
 
     Query<Customer> query = DB.find(Customer.class)
@@ -212,11 +201,12 @@ public class TestQueryFindIterate extends BaseTestCase {
       .where().gt("id", 0)
       .setMaxRows(2).query();
 
-    query.findEach(customer -> {
-      if (customer != null) {
-        throw new IllegalStateException("cause an exception");
-      }
-    });
+    assertThrows(IllegalStateException.class, () ->
+      query.findEach(customer -> {
+        if (customer != null) {
+          throw new IllegalStateException("cause an exception");
+        }
+      }));
   }
 
   @Test
@@ -232,10 +222,10 @@ public class TestQueryFindIterate extends BaseTestCase {
   public void findIterateCloseConnection(boolean withLoadBatch) {
     ResetBasicData.reset();
 
-    SpiServer pluginApi = server().getPluginApi();
-    DataSourcePool dsPool = (DataSourcePool) pluginApi.getServerConfig().getReadOnlyDataSource();
+    SpiServer pluginApi = server().pluginApi();
+    DataSourcePool dsPool = (DataSourcePool) pluginApi.config().getReadOnlyDataSource();
     if (dsPool == null) {
-      dsPool = (DataSourcePool) server().getDataSource();
+      dsPool = (DataSourcePool) server().dataSource();
     }
 
     int startConns = dsPool.getStatus(false).getBusy();
@@ -267,7 +257,7 @@ public class TestQueryFindIterate extends BaseTestCase {
 
     assertFalse(queryIterator.hasNext());
     assertThat(dsPool.getStatus(false).getBusy()).isEqualTo(startConns);
-    try  {
+    try {
       queryIterator.next();
       fail("noSuchElementException expected");
     } catch (NoSuchElementException e) {
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFindMapTypedKey.java b/ebean-test/src/test/java/org/tests/query/TestQueryFindMapTypedKey.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFindMapTypedKey.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFindMapTypedKey.java
index 8ea8457a0..e1e091f15 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFindMapTypedKey.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFindMapTypedKey.java
@@ -1,8 +1,8 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.Product;
@@ -11,7 +11,7 @@ import org.tests.model.basic.ResetBasicData;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestQueryFindMapTypedKey extends BaseTestCase {
 
@@ -20,7 +20,7 @@ public class TestQueryFindMapTypedKey extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Map<String, Product> productsBySku = Ebean.find(Product.class)
+    Map<String, Product> productsBySku = DB.find(Product.class)
       .setMapKey("sku")
       .findMap();
 
@@ -29,7 +29,7 @@ public class TestQueryFindMapTypedKey extends BaseTestCase {
     Product desk = productsBySku.get("DSK1");
     assertNotNull(desk);
 
-    Map<String, Customer> map = Ebean.find(Customer.class)
+    Map<String, Customer> map = DB.find(Customer.class)
       .select("id, name")
       .setMapKey("name")
       .findMap();
@@ -42,7 +42,7 @@ public class TestQueryFindMapTypedKey extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Map<Object, Order> orderMap = Ebean.find(Order.class)
+    Map<Object, Order> orderMap = DB.find(Order.class)
       .where().eq("status", Order.Status.NEW)
       .setMapKey("customer.id")
       .findMap();
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFindNative.java b/ebean-test/src/test/java/org/tests/query/TestQueryFindNative.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFindNative.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFindNative.java
index 8e11d3328..b3c229f71 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFindNative.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFindNative.java
@@ -4,9 +4,9 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.FetchConfig;
 import io.ebean.PagedList;
+import io.ebean.test.LoggedSql;
 import org.assertj.core.util.Lists;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
@@ -23,13 +23,13 @@ public class TestQueryFindNative extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     String sql = "select id,first_name from contact where id in(:ids)";
     DB.findNative(Contact.class, sql).setParameter("ids", Lists.newArrayList(1, 2, 3)).findList();
     DB.findNative(Contact.class, sql).setParameter("ids", Lists.newArrayList(1, 2)).findList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(2);
     if (isH2()) {
       assertThat(loggedSql.get(0)).contains("(?,?,?)");
@@ -43,7 +43,7 @@ public class TestQueryFindNative extends BaseTestCase {
     ResetBasicData.reset();
     String sql = "select n.id from contact n where n.first_name like ?";
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     int rowCount = server()
       .findNative(Contact.class, sql)
@@ -56,7 +56,7 @@ public class TestQueryFindNative extends BaseTestCase {
         .setParameter(1, "J%")
         .findIds();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(nativeIds).hasSize(rowCount);
 
@@ -77,12 +77,12 @@ public class TestQueryFindNative extends BaseTestCase {
       .setMaxRows(100)
       .findPagedList();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     int listSize = pagedList.getList().size();
     int totalCount = pagedList.getTotalCount();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(listSize).isEqualTo(totalCount);
 
@@ -124,7 +124,7 @@ public class TestQueryFindNative extends BaseTestCase {
 
     List<Integer> ids = DB.sqlQuery(sql)
       .setParameter(1, "J%")
-      .findSingleAttributeList(Integer.class);
+      .mapToScalar(Integer.class).findList();
 
     List<Integer> idsScalar =
       server()
@@ -204,7 +204,7 @@ public class TestQueryFindNative extends BaseTestCase {
       "from o_customer " +
       "order by order_column_1";
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Customer> result = DB.findNative(Customer.class, sql)
       .setParameter(LocalDate.now())
@@ -214,7 +214,7 @@ public class TestQueryFindNative extends BaseTestCase {
       .findList();
 
     assertThat(result).isNotEmpty();
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     if (isH2()) {
       assertThat(loggedSql.get(0)).contains("from o_customer order by order_column_1 limit 10 offset 1");
@@ -231,7 +231,7 @@ public class TestQueryFindNative extends BaseTestCase {
       "from o_customer " +
       "order by order_column_1";
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Customer> result = DB.findNative(Customer.class, sql)
       .setParameter("date", LocalDate.now())
@@ -240,7 +240,7 @@ public class TestQueryFindNative extends BaseTestCase {
       .findList();
 
     assertThat(result).isNotEmpty();
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     if (isH2()) {
       assertThat(loggedSql.get(0)).contains("from o_customer order by order_column_1 limit 10 offset 1");
@@ -255,14 +255,14 @@ public class TestQueryFindNative extends BaseTestCase {
 
     String sql = "select * from o_customer";
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Customer> result = DB.findNative(Customer.class, sql)
             .fetchQuery("contacts")
             .findList();
 
     assertThat(result).isNotEmpty();
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     if (isH2()) {
       assertThat(loggedSql).hasSize(2);
@@ -278,14 +278,14 @@ public class TestQueryFindNative extends BaseTestCase {
 
     String sql = "select * from o_customer";
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Customer> result = DB.findNative(Customer.class, sql)
             .fetch("contacts", "firstName, lastName")
             .findList();
 
     assertThat(result).isNotEmpty();
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     if (isH2()) {
       assertThat(loggedSql).hasSize(2);
@@ -301,7 +301,7 @@ public class TestQueryFindNative extends BaseTestCase {
 
     String sql = "select * from o_customer";
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Customer> result = DB.findNative(Customer.class, sql)
             .fetchQuery("orders")
@@ -309,7 +309,7 @@ public class TestQueryFindNative extends BaseTestCase {
             .findList();
 
     assertThat(result).isNotEmpty();
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     if (isH2()) {
       assertThat(loggedSql).hasSize(3);
@@ -326,7 +326,7 @@ public class TestQueryFindNative extends BaseTestCase {
 
     String sql = "select * from o_customer";
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Customer> result = DB.findNative(Customer.class, sql)
             // with nativeSql fetch (default) are converted to fetchQuery()
@@ -335,7 +335,7 @@ public class TestQueryFindNative extends BaseTestCase {
             .findList();
 
     assertThat(result).isNotEmpty();
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     if (isH2()) {
       assertThat(loggedSql).hasSize(3);
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFindPagedList.java b/ebean-test/src/test/java/org/tests/query/TestQueryFindPagedList.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFindPagedList.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFindPagedList.java
index 16e1e8ee3..580f821dc 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFindPagedList.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFindPagedList.java
@@ -1,10 +1,10 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.PagedList;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
@@ -17,9 +17,7 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryFindPagedList extends BaseTestCase {
 
@@ -37,29 +35,28 @@ public class TestQueryFindPagedList extends BaseTestCase {
     assertThat(empty.getDisplayXtoYofZ("a", "b")).isEqualTo("");
   }
 
-  @Test(expected = PersistenceException.class)
+  @Test
   public void test_noMaxRows() {
-
-    Ebean.find(Order.class).findPagedList();
+    assertThrows(PersistenceException.class, () ->
+      DB.find(Order.class).findPagedList());
   }
 
   @Test
   public void test_maxRows_NoCount() {
-
     ResetBasicData.reset();
 
-    PagedList<Order> pagedList = Ebean.find(Order.class)
+    PagedList<Order> pagedList = DB.find(Order.class)
       .setMaxRows(4)
       .findPagedList();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Order> orders = pagedList.getList();
 
     assertTrue(!orders.isEmpty());
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
-    assertEquals("Only 1 SQL statement, no count query", 1, loggedSql.size());
+    assertEquals(1, loggedSql.size());
   }
 
 
@@ -68,7 +65,7 @@ public class TestQueryFindPagedList extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    PagedList<Order> pagedList = Ebean.find(Order.class)
+    PagedList<Order> pagedList = DB.find(Order.class)
       .setMaxRows(3)
       .findPagedList();
 
@@ -91,7 +88,7 @@ public class TestQueryFindPagedList extends BaseTestCase {
     ResetBasicData.reset();
 
     // fetch less that total orders (page size 3)
-    PagedList<Order> pagedList = Ebean.find(Order.class)
+    PagedList<Order> pagedList = DB.find(Order.class)
       .setMaxRows(3)
       .findPagedList();
 
@@ -105,7 +102,7 @@ public class TestQueryFindPagedList extends BaseTestCase {
 
 
     // fetch less that total orders (page size 3)
-    PagedList<Order> pagedList2 = Ebean.find(Order.class)
+    PagedList<Order> pagedList2 = DB.find(Order.class)
       .setFirstRow(1)
       .setMaxRows(3)
       .order("id")
@@ -121,7 +118,7 @@ public class TestQueryFindPagedList extends BaseTestCase {
     assertThat(orders2.size()).isLessThan(totalRowCount);
 
 
-    PagedList<Order> pagedList3 = Ebean.find(Order.class)
+    PagedList<Order> pagedList3 = DB.find(Order.class)
       .setFirstRow(2)
       .setMaxRows(150)
       .order("id")
@@ -135,7 +132,7 @@ public class TestQueryFindPagedList extends BaseTestCase {
     assertThat(xtoYofZ).isEqualTo("3 to " + totalRowCount + " of " + totalRowCount);
     assertThat(list3.size()).isEqualTo(totalRowCount - 2);
 
-    PagedList<Order> pagedList4 = Ebean.find(Order.class)
+    PagedList<Order> pagedList4 = DB.find(Order.class)
       .setFirstRow(0)
       .setMaxRows(totalRowCount)
       .findPagedList();
@@ -144,7 +141,7 @@ public class TestQueryFindPagedList extends BaseTestCase {
     assertFalse(pagedList4.hasPrev());
     assertThat(pagedList4.getDisplayXtoYofZ(" to ", " of ")).isEqualTo("1 to " + totalRowCount + " of " + totalRowCount);
 
-    PagedList<Order> pagedList5 = Ebean.find(Order.class)
+    PagedList<Order> pagedList5 = DB.find(Order.class)
       .setFirstRow(0)
       .setMaxRows(totalRowCount - 1)
       .findPagedList();
@@ -158,16 +155,16 @@ public class TestQueryFindPagedList extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    PagedList<Order> pagedList = Ebean.find(Order.class).setMaxRows(4).findPagedList();
+    PagedList<Order> pagedList = DB.find(Order.class).setMaxRows(4).findPagedList();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Order> orders = pagedList.getList();
 
     assertTrue(!orders.isEmpty());
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
-    assertEquals("Only 1 SQL statement, no count query", 1, loggedSql.size());
+    assertEquals(1, loggedSql.size());
   }
 
   @Test
@@ -175,7 +172,7 @@ public class TestQueryFindPagedList extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    PagedList<Order> pagedList = Ebean.find(Order.class).setMaxRows(3).findPagedList();
+    PagedList<Order> pagedList = DB.find(Order.class).setMaxRows(3).findPagedList();
 
     Future<Integer> rowCount = pagedList.getFutureCount();
     List<Order> orders = pagedList.getList();
@@ -197,7 +194,7 @@ public class TestQueryFindPagedList extends BaseTestCase {
     ResetBasicData.reset();
 
     // fetch less that total orders (page size 3)
-    PagedList<Order> pagedList = Ebean.find(Order.class).setMaxRows(3).findPagedList();
+    PagedList<Order> pagedList = DB.find(Order.class).setMaxRows(3).findPagedList();
 
     pagedList.loadCount();
     List<Order> orders = pagedList.getList();
@@ -212,14 +209,14 @@ public class TestQueryFindPagedList extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    PagedList<Order> pagedList = Ebean.find(Order.class).setMaxRows(3).findPagedList();
+    PagedList<Order> pagedList = DB.find(Order.class).setMaxRows(3).findPagedList();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // kinda not normal but just wrap in a transaction to assert
     // the background fetch does not occur (which explicitly creates
     // its own transaction) ... so a bit naughty with the test here
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
 
       List<Order> orders = pagedList.getList();
@@ -228,7 +225,7 @@ public class TestQueryFindPagedList extends BaseTestCase {
       // invoke it again but cached...
       int totalRowCountAgain = pagedList.getTotalCount();
 
-      List<String> loggedSql = LoggedSqlCollector.stop();
+      List<String> loggedSql = LoggedSql.stop();
 
       assertTrue(orders.size() < totalRowCount);
       assertEquals(2, loggedSql.size());
@@ -240,7 +237,7 @@ public class TestQueryFindPagedList extends BaseTestCase {
       assertEquals(firstTxn, secTxn);
 
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
   }
 
@@ -250,18 +247,18 @@ public class TestQueryFindPagedList extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    PagedList<Order> pagedList = Ebean.find(Order.class)
+    PagedList<Order> pagedList = DB.find(Order.class)
       .alias("b")
       .where().raw("b.id > 0")
       .setMaxRows(6)
       .findPagedList();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     pagedList.getTotalCount();
     pagedList.getList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertEquals(2, loggedSql.size());
     assertThat(loggedSql.get(0)).contains("select count(*) from o_order b where b.id > 0");
diff --git a/ebean-test/src/test/java/org/tests/query/TestQueryFindReadOnly.java b/ebean-test/src/test/java/org/tests/query/TestQueryFindReadOnly.java
new file mode 100644
index 000000000..78be3b140
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFindReadOnly.java
@@ -0,0 +1,49 @@
+package org.tests.query;
+
+import io.ebean.BaseTestCase;
+import io.ebean.CacheMode;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Article;
+import org.tests.model.basic.Section;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestQueryFindReadOnly extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Section s0 = new Section("some content");
+    Article a0 = new Article("art1", "auth1");
+    a0.addSection(s0);
+
+    DB.save(a0);
+
+    Article ar1 = DB.find(Article.class).setReadOnly(true).setId(a0.getId()).findOne();
+
+    assertNotNull(ar1);
+    assertTrue(DB.beanState(ar1).isReadOnly());
+
+    List<Section> ar1sections = ar1.getSections();
+    assertEquals(1, ar1sections.size());
+
+    Section s2 = ar1sections.get(0);
+    assertTrue(DB.beanState(s2).isReadOnly());
+
+    DB.find(Article.class).setBeanCacheMode(CacheMode.PUT).findList();
+
+    Article ar0 = DB.find(Article.class, a0.getId());
+
+    assertNotNull(ar0);
+    assertFalse(DB.beanState(ar0).isReadOnly());
+
+    List<Section> ar0sections = ar0.getSections();
+    Section s1 = ar0sections.get(0);
+    assertFalse(DB.beanState(s1).isReadOnly());
+
+  }
+
+}
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryFindStream.java b/ebean-test/src/test/java/org/tests/query/TestQueryFindStream.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/query/TestQueryFindStream.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryFindStream.java
index c4a852f38..63a6c5c8f 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryFindStream.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryFindStream.java
@@ -2,7 +2,7 @@ package org.tests.query;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryInAssocOne.java b/ebean-test/src/test/java/org/tests/query/TestQueryInAssocOne.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/query/TestQueryInAssocOne.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryInAssocOne.java
index 9de07f3ff..77a3088cc 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryInAssocOne.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryInAssocOne.java
@@ -1,12 +1,12 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -19,9 +19,9 @@ public class TestQueryInAssocOne extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class).where().lt("id", 200).findList();
+    List<Customer> list = DB.find(Customer.class).where().lt("id", 200).findList();
 
-    Query<Order> query = Ebean.find(Order.class).where().in("customer", list).query();
+    Query<Order> query = DB.find(Order.class).where().in("customer", list).query();
 
     query.findList();
     String sql = query.getGeneratedSql();
@@ -36,9 +36,9 @@ public class TestQueryInAssocOne extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class).where().lt("id", 300).findList();
+    List<Customer> list = DB.find(Customer.class).where().lt("id", 300).findList();
 
-    Query<Order> query = Ebean.find(Order.class).where().isIn("customer", list).query();
+    Query<Order> query = DB.find(Order.class).where().isIn("customer", list).query();
 
     query.findList();
     String sql = query.getGeneratedSql();
@@ -53,9 +53,9 @@ public class TestQueryInAssocOne extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class).where().lt("id", 200).findList();
+    List<Customer> list = DB.find(Customer.class).where().lt("id", 200).findList();
 
-    Query<Order> query = Ebean.find(Order.class).where().notIn("customer", list).query();
+    Query<Order> query = DB.find(Order.class).where().notIn("customer", list).query();
 
     query.findList();
     String sql = query.getGeneratedSql();
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryInIdTypeConversion.java b/ebean-test/src/test/java/org/tests/query/TestQueryInIdTypeConversion.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/query/TestQueryInIdTypeConversion.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryInIdTypeConversion.java
index d92e3e096..72a6d98a5 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryInIdTypeConversion.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryInIdTypeConversion.java
@@ -2,7 +2,7 @@ package org.tests.query;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryIsNull.java b/ebean-test/src/test/java/org/tests/query/TestQueryIsNull.java
similarity index 99%
rename from ebean-core/src/test/java/org/tests/query/TestQueryIsNull.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryIsNull.java
index f80aee9f5..f93a9e450 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryIsNull.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryIsNull.java
@@ -3,11 +3,10 @@ package org.tests.query;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 import org.tests.model.m2m.Role;
-import org.junit.Test;
-
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryJoinBatchSize.java b/ebean-test/src/test/java/org/tests/query/TestQueryJoinBatchSize.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/query/TestQueryJoinBatchSize.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryJoinBatchSize.java
index 721939ef9..fa478dd20 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryJoinBatchSize.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryJoinBatchSize.java
@@ -1,12 +1,11 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -17,7 +16,7 @@ public class TestQueryJoinBatchSize extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Order> list = Ebean.find(Order.class)
+    List<Order> list = DB.find(Order.class)
       .fetch("customer")
       //.fetch("orders.details", new FetchConfig().query())
       //.fetch("orders.shipments", new FetchConfig().query())
@@ -35,7 +34,7 @@ public class TestQueryJoinBatchSize extends BaseTestCase {
 //
 //    ResetBasicData.reset();
 //
-//    Ebean.find(Customer.class)
+//    DB.find(Customer.class)
 //        .fetch("orders", new FetchConfig().query(3).lazy(2))
 //        //.fetch("orders.details", new FetchConfig().query())
 //        //.fetch("orders.shipments", new FetchConfig().query())
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryJoinMulipleMany.java b/ebean-test/src/test/java/org/tests/query/TestQueryJoinMulipleMany.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/query/TestQueryJoinMulipleMany.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryJoinMulipleMany.java
index b4cf4e8ac..171df676f 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryJoinMulipleMany.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryJoinMulipleMany.java
@@ -1,15 +1,16 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestQueryJoinMulipleMany extends BaseTestCase {
 
   @Test
@@ -17,10 +18,10 @@ public class TestQueryJoinMulipleMany extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Order> list = Ebean.find(Order.class).fetch("customer").fetch("customer.contacts").where()
+    List<Order> list = DB.find(Order.class).fetch("customer").fetch("customer.contacts").where()
       .gt("id", 0).findList();
 
-    Assert.assertNotNull(list);
+    assertNotNull(list);
 
     for (Order order : list) {
       List<Contact> contacts = order.getCustomer().getContacts();
diff --git a/ebean-test/src/test/java/org/tests/query/TestQueryMultiManyOrder.java b/ebean-test/src/test/java/org/tests/query/TestQueryMultiManyOrder.java
new file mode 100644
index 000000000..a67aaec76
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryMultiManyOrder.java
@@ -0,0 +1,36 @@
+package org.tests.query;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.Query;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class TestQueryMultiManyOrder extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Query<Order> q = DB.find(Order.class).fetch("shipments").fetch("details")
+      .fetch("details.product").fetch("customer").where().gt("id", 0).query();
+
+    List<Order> list = q.findList();
+    String sql = q.getGeneratedSql();
+
+    assertTrue(!list.isEmpty());
+    assertTrue(sql.contains("join o_customer "));
+
+    assertFalse(sql.contains("left join contact "));
+    assertFalse(sql.contains("left join o_order_detail "));
+    assertFalse(sql.contains("left join o_product "));
+
+  }
+}
diff --git a/ebean-test/src/test/java/org/tests/query/TestQueryNullAssocOne.java b/ebean-test/src/test/java/org/tests/query/TestQueryNullAssocOne.java
new file mode 100644
index 000000000..c48c11f87
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryNullAssocOne.java
@@ -0,0 +1,47 @@
+package org.tests.query;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.Query;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class TestQueryNullAssocOne extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Query<Order> q0 = DB.find(Order.class).where().eq("customer", null).query();
+
+    List<Order> orders = q0.findList();
+    assertNotNull(orders);
+    assertTrue(q0.getGeneratedSql().contains("where t0.kcustomer_id is null"));
+
+    Query<Order> q1 = DB.find(Order.class).where().eq("customer.id", null).query();
+
+    List<Order> o1 = q1.findList();
+    assertTrue(o1.size() == orders.size());
+    assertTrue(q1.getGeneratedSql().contains("where t0.kcustomer_id is null"));
+
+    Query<Order> q2 = DB.find(Order.class).where().isNull("customer").query();
+
+    List<Order> o2 = q2.findList();
+    assertTrue(o2.size() == orders.size());
+    assertTrue(q2.getGeneratedSql().contains("where t0.kcustomer_id is null"));
+
+    Query<Order> q3 = DB.find(Order.class).where().isNull("customer").query();
+
+    List<Order> o3 = q3.findList();
+    assertTrue(o3.size() == orders.size());
+    assertTrue(q3.getGeneratedSql().contains("where t0.kcustomer_id is null"));
+
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryOrderById.java b/ebean-test/src/test/java/org/tests/query/TestQueryOrderById.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/query/TestQueryOrderById.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryOrderById.java
index 3c536a6f8..f98a0c04d 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryOrderById.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryOrderById.java
@@ -3,11 +3,9 @@ package org.tests.query;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 public class TestQueryOrderById extends BaseTestCase {
 
   @Test
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryPathJoinAndOrder.java b/ebean-test/src/test/java/org/tests/query/TestQueryPathJoinAndOrder.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/query/TestQueryPathJoinAndOrder.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryPathJoinAndOrder.java
index 74ea5496b..1d41c026e 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryPathJoinAndOrder.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryPathJoinAndOrder.java
@@ -1,14 +1,15 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestQueryPathJoinAndOrder extends BaseTestCase {
 
   @Test
@@ -16,10 +17,10 @@ public class TestQueryPathJoinAndOrder extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class).select("id,name, status").fetch("contacts")
+    List<Customer> list = DB.find(Customer.class).select("id,name, status").fetch("contacts")
       .order().asc("id").order().desc("contacts.firstName").setMaxRows(3).findList();
 
-    Assert.assertNotNull(list);
+    assertNotNull(list);
 
     // can't really assert that the contacts are batch loaded
     // via a secondary query join
diff --git a/ebean-core/src/test/java/org/tests/query/TestQueryPlanCacheRowCount.java b/ebean-test/src/test/java/org/tests/query/TestQueryPlanCacheRowCount.java
similarity index 60%
rename from ebean-core/src/test/java/org/tests/query/TestQueryPlanCacheRowCount.java
rename to ebean-test/src/test/java/org/tests/query/TestQueryPlanCacheRowCount.java
index 0abc2b414..fb1fac598 100644
--- a/ebean-core/src/test/java/org/tests/query/TestQueryPlanCacheRowCount.java
+++ b/ebean-test/src/test/java/org/tests/query/TestQueryPlanCacheRowCount.java
@@ -1,15 +1,17 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+
 public class TestQueryPlanCacheRowCount extends BaseTestCase {
 
   @Test
@@ -17,25 +19,25 @@ public class TestQueryPlanCacheRowCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class).where().eq("status", Order.Status.NEW).ge("id", 1)
+    Query<Order> query = DB.find(Order.class).where().eq("status", Order.Status.NEW).ge("id", 1)
       .order().desc("id");
 
     int rc0 = query.findCount();
 
     List<Integer> ids = query.findIds();
-    Assert.assertEquals(rc0, ids.size());
+    assertEquals(rc0, ids.size());
 
     List<Order> list0 = query.findList();
-    Assert.assertEquals(rc0, list0.size());
+    assertEquals(rc0, list0.size());
 
     int rc1 = query.findCount();
-    Assert.assertEquals(rc0, rc1);
+    assertEquals(rc0, rc1);
 
     List<Integer> ids1 = query.findIds();
-    Assert.assertEquals(rc0, ids1.size());
+    assertEquals(rc0, ids1.size());
 
     List<Order> list1 = query.findList();
-    Assert.assertEquals(rc0, list1.size());
+    assertEquals(rc0, list1.size());
 
     int idGt = 5;
     if (!ids1.isEmpty()) {
@@ -44,19 +46,19 @@ public class TestQueryPlanCacheRowCount extends BaseTestCase {
     }
 
     // should still hit query plan cache
-    Query<Order> query2 = Ebean.find(Order.class).where().eq("status", Order.Status.NEW)
+    Query<Order> query2 = DB.find(Order.class).where().eq("status", Order.Status.NEW)
       .ge("id", idGt).order().desc("id");
 
     int rc2 = query2.findCount();
 
     System.out.println("Expection Not same " + rc0 + " != " + rc2);
-    Assert.assertNotSame(rc0, rc2);
+    assertNotSame(rc0, rc2);
 
     List<Integer> ids2 = query2.findIds();
-    Assert.assertEquals(rc2, ids2.size());
+    assertEquals(rc2, ids2.size());
 
     List<Order> list2 = query2.findList();
-    Assert.assertEquals(rc2, list2.size());
+    assertEquals(rc2, list2.size());
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/query/TestRefToLazyLoadMany.java b/ebean-test/src/test/java/org/tests/query/TestRefToLazyLoadMany.java
similarity index 64%
rename from ebean-core/src/test/java/org/tests/query/TestRefToLazyLoadMany.java
rename to ebean-test/src/test/java/org/tests/query/TestRefToLazyLoadMany.java
index 340b6c275..5b0e4c931 100644
--- a/ebean-core/src/test/java/org/tests/query/TestRefToLazyLoadMany.java
+++ b/ebean-test/src/test/java/org/tests/query/TestRefToLazyLoadMany.java
@@ -1,15 +1,16 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestRefToLazyLoadMany extends BaseTestCase {
 
   @Test
@@ -17,21 +18,21 @@ public class TestRefToLazyLoadMany extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> custList = Ebean.find(Customer.class).select("id").findList();
+    List<Customer> custList = DB.find(Customer.class).select("id").findList();
 
     Customer c = custList.get(0);
 
     List<Contact> contacts2 = c.getContacts();
-    Assert.assertEquals(3, Ebean.getBeanState(c).getLoadedProps().size());
+    assertEquals(3, DB.beanState(c).loadedProps().size());
 
     // now lazy load the contacts
     contacts2.size();
 
-    Customer c2 = Ebean.getReference(Customer.class, c.getId());
+    Customer c2 = DB.reference(Customer.class, c.getId());
 
     // we only "loaded" the contacts BeanList and not all of c2
     List<Contact> contacts = c2.getContacts();
-    // Set<String> loadedProps = Ebean.getBeanState(c2).getLoadedProps();
+    // Set<String> loadedProps = DB.beanState(c2).getLoadedProps();
     // assertEquals(1, loadedProps.size());
 
     // now lazy load the contacts
diff --git a/ebean-core/src/test/java/org/tests/query/TestRowCount.java b/ebean-test/src/test/java/org/tests/query/TestRowCount.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/query/TestRowCount.java
rename to ebean-test/src/test/java/org/tests/query/TestRowCount.java
index d0c058a38..0d3f215c8 100644
--- a/ebean-core/src/test/java/org/tests/query/TestRowCount.java
+++ b/ebean-test/src/test/java/org/tests/query/TestRowCount.java
@@ -1,9 +1,9 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
@@ -11,7 +11,7 @@ import org.tests.model.basic.ResetBasicData;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestRowCount extends BaseTestCase {
 
@@ -20,7 +20,7 @@ public class TestRowCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .fetch("details")
       .where()
       .gt("id", 1)
@@ -37,16 +37,15 @@ public class TestRowCount extends BaseTestCase {
       order.getStatus();
     }
 
-    assertEquals("same rc to ids.size() ", rc, ids.size());
-    assertEquals("same rc to list.size()", rc, list.size());
+    assertEquals(rc, ids.size());
+    assertEquals(rc, list.size());
   }
 
   @Test
   public void find_count_distinct_singleProperty() {
-
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .setDistinct(true)
       .select("anniversary")
       .where().eq("status", Customer.Status.NEW)
@@ -63,7 +62,7 @@ public class TestRowCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .setDistinct(true)
       .select("anniversary, status");
 
diff --git a/ebean-core/src/test/java/org/tests/query/TestSubQuery.java b/ebean-test/src/test/java/org/tests/query/TestSubQuery.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/query/TestSubQuery.java
rename to ebean-test/src/test/java/org/tests/query/TestSubQuery.java
index 7386f9bac..469d525a1 100644
--- a/ebean-core/src/test/java/org/tests/query/TestSubQuery.java
+++ b/ebean-test/src/test/java/org/tests/query/TestSubQuery.java
@@ -3,7 +3,7 @@ package org.tests.query;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.*;
 
 import java.util.ArrayList;
@@ -151,10 +151,10 @@ public class TestSubQuery extends BaseTestCase {
    *
    * public void testInheritance1() { ResetBasicData.reset();
    *
-   * Query<Vehicle> sq = Ebean.createQuery(Vehicle.class) .select("id")
+   * Query<Vehicle> sq = DB.createQuery(Vehicle.class) .select("id")
    * .setAutoTune(false) .where() .query();
    *
-   * Query<VehicleDriver> pq = Ebean.find(VehicleDriver.class)
+   * Query<VehicleDriver> pq = DB.find(VehicleDriver.class)
    * .where().in("vehicle.id", sq) .query();
    *
    * pq.findList();
diff --git a/ebean-core/src/test/java/org/tests/query/TestThreeLevelQueryJoin.java b/ebean-test/src/test/java/org/tests/query/TestThreeLevelQueryJoin.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/query/TestThreeLevelQueryJoin.java
rename to ebean-test/src/test/java/org/tests/query/TestThreeLevelQueryJoin.java
index 315a4263a..8b2ed0939 100644
--- a/ebean-core/src/test/java/org/tests/query/TestThreeLevelQueryJoin.java
+++ b/ebean-test/src/test/java/org/tests/query/TestThreeLevelQueryJoin.java
@@ -1,11 +1,10 @@
 package org.tests.query;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 public class TestThreeLevelQueryJoin extends BaseTestCase {
 
@@ -14,7 +13,7 @@ public class TestThreeLevelQueryJoin extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Ebean.find(Customer.class).fetchQuery("orders")
+    DB.find(Customer.class).fetchQuery("orders")
       .fetchQuery("orders.details")
       .fetchQuery("orders.shipments")
       .fetchQuery("shippingAddress")
diff --git a/ebean-core/src/test/java/org/tests/query/TestWhereIn.java b/ebean-test/src/test/java/org/tests/query/TestWhereIn.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/query/TestWhereIn.java
rename to ebean-test/src/test/java/org/tests/query/TestWhereIn.java
index 410a24840..618b20363 100644
--- a/ebean-core/src/test/java/org/tests/query/TestWhereIn.java
+++ b/ebean-test/src/test/java/org/tests/query/TestWhereIn.java
@@ -3,7 +3,7 @@ package org.tests.query;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
diff --git a/ebean-core/src/test/java/org/tests/query/TestWhereRawClause.java b/ebean-test/src/test/java/org/tests/query/TestWhereRawClause.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/query/TestWhereRawClause.java
rename to ebean-test/src/test/java/org/tests/query/TestWhereRawClause.java
index f98ff3d81..ebb5ce146 100644
--- a/ebean-core/src/test/java/org/tests/query/TestWhereRawClause.java
+++ b/ebean-test/src/test/java/org/tests/query/TestWhereRawClause.java
@@ -2,13 +2,12 @@ package org.tests.query;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.Expr;
 import io.ebean.Query;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
@@ -29,7 +28,7 @@ public class TestWhereRawClause extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .where()
       .raw("(status = ? or (orderDate < ? and shipDate is null) or customer.name like ?)",
         Order.Status.APPROVED, new Timestamp(System.currentTimeMillis()), "Rob")
@@ -45,7 +44,7 @@ public class TestWhereRawClause extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Ebean.find(OrderDetail.class)
+    DB.find(OrderDetail.class)
       .where()
       .not(Expr.eq("id", 1))
       .raw("orderQty < shipQty")
@@ -75,7 +74,7 @@ public class TestWhereRawClause extends BaseTestCase {
 
     List<String> vals = asList("Rob", "Fiona", "Jack");
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("name")
       .where()
       .rawOrEmpty("id in (select c.id from o_customer c where c.name in (?1))", vals)
@@ -91,7 +90,7 @@ public class TestWhereRawClause extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("name")
       .where()
       .rawOrEmpty("id in (select c.id from o_customer c where c.name in (?1))", null)
@@ -107,7 +106,7 @@ public class TestWhereRawClause extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("name")
       .where()
       .rawOrEmpty("id in (select c.id from o_customer c where c.name in (?1))", Collections.emptySet())
@@ -123,7 +122,7 @@ public class TestWhereRawClause extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .where()
       .raw("name in (?1)", asList("Rob", "Fiona", "Jack"))
       .query();
@@ -139,7 +138,7 @@ public class TestWhereRawClause extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class)
+    List<Customer> list = DB.find(Customer.class)
       .where()
       .raw("name = any(?)", asList("Rob", "Fiona", "Jack"))
       .findList();
@@ -153,21 +152,21 @@ public class TestWhereRawClause extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(Customer.class)
+    DB.find(Customer.class)
       .select("name").where().rawOrEmpty("name = any(?)", asList("Rob", "Fiona", "Jack"))
       .findList();
 
-    Ebean.find(Customer.class)
+    DB.find(Customer.class)
       .select("name").where().rawOrEmpty("name = any(?)", asList())
       .findList();
 
-    Ebean.find(Customer.class)
+    DB.find(Customer.class)
       .select("name").where().rawOrEmpty("name = any(?)", null)
       .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql.get(0)).contains("select t0.id, t0.name from o_customer t0 where t0.name = any(?);");
     assertThat(sql.get(1)).contains("select t0.id, t0.name from o_customer t0; --bind()");
@@ -179,7 +178,7 @@ public class TestWhereRawClause extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Ebean.find(OrderDetail.class)
+    DB.find(OrderDetail.class)
       .where()
       .ne("id", 42)
       .raw("orderQty < ?", 100)
diff --git a/ebean-core/src/test/java/org/tests/query/aggregation/TestAggregationCount.java b/ebean-test/src/test/java/org/tests/query/aggregation/TestAggregationCount.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/query/aggregation/TestAggregationCount.java
rename to ebean-test/src/test/java/org/tests/query/aggregation/TestAggregationCount.java
index 261202696..f60686f3d 100644
--- a/ebean-core/src/test/java/org/tests/query/aggregation/TestAggregationCount.java
+++ b/ebean-test/src/test/java/org/tests/query/aggregation/TestAggregationCount.java
@@ -1,12 +1,11 @@
 package org.tests.query.aggregation;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import io.ebeantest.LoggedSql;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
@@ -22,30 +21,30 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestAggregationCount extends BaseTestCase {
 
-  @BeforeClass
+  @BeforeAll
   public static void setup() {
     TEventOne one = new TEventOne("first", TEventOne.Status.AA);
     one.getLogs().add(new TEventMany("all", 1, 10));
     one.getLogs().add(new TEventMany("be", 2, 12.2));
     one.getLogs().add(new TEventMany("add", 3, 13));
-    Ebean.save(one);
+    DB.save(one);
 
     TEventOne two = new TEventOne("second", TEventOne.Status.AA);
     two.getLogs().add(new TEventMany("at", 10, 10));
     two.getLogs().add(new TEventMany("add", 30, 13));
     two.getLogs().add(new TEventMany("alf", 30, 13));
-    Ebean.save(two);
+    DB.save(two);
 
     TEventOne three = new TEventOne("thrird", TEventOne.Status.BB);
-    Ebean.save(three);
+    DB.save(three);
     three.setName("third");
-    Ebean.save(three);
+    DB.save(three);
   }
 
   @Test
   public void testBaseSelect() {
 
-    Query<TEventOne> query = Ebean.find(TEventOne.class);
+    Query<TEventOne> query = DB.find(TEventOne.class);
     List<TEventOne> list = query.findList();
 
     String sql = sqlOf(query, 5);
@@ -64,23 +63,23 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     int count =
-      Ebean.find(TEventOne.class)
+      DB.find(TEventOne.class)
         .where().isNotNull("name")
         .findCount();
 
     assertThat(count).isGreaterThan(1);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select count(*) from tevent_one t0 where t0.name is not null");
   }
 
   @Test
   public void testNonAggregationLazyLoading() {
 
-    Query<TEventOne> query = Ebean.find(TEventOne.class).select("id");
+    Query<TEventOne> query = DB.find(TEventOne.class).select("id");
     List<TEventOne> list = query.findList();
 
     String sql = sqlOf(query, 5);
@@ -94,7 +93,7 @@ public class TestAggregationCount extends BaseTestCase {
 
   @Test
   public void findCount_withHaving() {
-    Query<TEventOne> query = Ebean.find(TEventOne.class)
+    Query<TEventOne> query = DB.find(TEventOne.class)
       //.select("id, totalUnits")
       .having()
       .ge("totalUnits", 1)
@@ -111,7 +110,7 @@ public class TestAggregationCount extends BaseTestCase {
   @Test
   public void testFull() {
 
-    Query<TEventOne> query2 = Ebean.find(TEventOne.class)
+    Query<TEventOne> query2 = DB.find(TEventOne.class)
       .select("name, count, totalUnits, totalAmount")
       .where()
       .startsWith("logs.description", "a")
@@ -140,7 +139,7 @@ public class TestAggregationCount extends BaseTestCase {
   @Test
   public void testOrderByTotal() {
 
-    Query<TEventOne> query = Ebean.find(TEventOne.class)
+    Query<TEventOne> query = DB.find(TEventOne.class)
       .select("name, count, totalUnits, totalAmount")
       .order().asc("totalUnits").order().asc("name");
 
@@ -161,7 +160,7 @@ public class TestAggregationCount extends BaseTestCase {
   @Test
   public void testSelectSome() {
 
-    Query<TEventOne> query0 = Ebean.find(TEventOne.class)
+    Query<TEventOne> query0 = DB.find(TEventOne.class)
       .select("name, count, totalUnits");
 
     query0.findList();
@@ -173,7 +172,7 @@ public class TestAggregationCount extends BaseTestCase {
   @Test
   public void testSelectOnly() {
 
-    Query<TEventOne> query0 = Ebean.find(TEventOne.class)
+    Query<TEventOne> query0 = DB.find(TEventOne.class)
       .select("name, count, totalUnits, totalAmount");
 
     query0.findList();
@@ -185,7 +184,7 @@ public class TestAggregationCount extends BaseTestCase {
   @Test
   public void testSelectWhere() {
 
-    Query<TEventOne> query0 = Ebean.find(TEventOne.class)
+    Query<TEventOne> query0 = DB.find(TEventOne.class)
       .select("name, count, totalUnits, totalAmount")
       .where().gt("logs.description", "a").query();
 
@@ -198,7 +197,7 @@ public class TestAggregationCount extends BaseTestCase {
   @Test
   public void testSelectHavingOrderBy() {
 
-    Query<TEventOne> query1 = Ebean.find(TEventOne.class)
+    Query<TEventOne> query1 = DB.find(TEventOne.class)
       .select("name, count, totalUnits, totalAmount")
       .having().ge("count", 1)
       .order().asc("name");
@@ -210,7 +209,7 @@ public class TestAggregationCount extends BaseTestCase {
   @Test
   public void testSelectWithFetch() {
 
-    Query<TEventOne> query0 = Ebean.find(TEventOne.class)
+    Query<TEventOne> query0 = DB.find(TEventOne.class)
       .select("name, count")
       .fetch("event", "name");
 
@@ -223,7 +222,7 @@ public class TestAggregationCount extends BaseTestCase {
   @Test
   public void testTopLevelAggregation() {
 
-    Query<TEventOne> query0 = Ebean.find(TEventOne.class)
+    Query<TEventOne> query0 = DB.find(TEventOne.class)
       .select("status, maxVersion")
       .where().isNotNull("name")
       .having().ge("maxVersion", 1)
@@ -238,7 +237,7 @@ public class TestAggregationCount extends BaseTestCase {
     assertThat(sql).contains("having max(t0.version) >= ?");
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     for (TEventOne eventOne : list) {
       assertThat(eventOne.getStatus()).isNotNull();
@@ -250,7 +249,7 @@ public class TestAggregationCount extends BaseTestCase {
       assertThat(eventOne.getName()).isNull();
     }
 
-    List<String> lazyLoadSql = LoggedSqlCollector.stop();
+    List<String> lazyLoadSql = LoggedSql.stop();
     assertThat(lazyLoadSql).isEmpty();
   }
 
@@ -259,7 +258,7 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query0 = Ebean.find(Order.class)
+    Query<Order> query0 = DB.find(Order.class)
       .select("max(updtime)")
       .where().eq("status", Order.Status.NEW)
       .query();
@@ -270,7 +269,7 @@ public class TestAggregationCount extends BaseTestCase {
     String sql = sqlOf(query0, 5);
     assertThat(sql).contains("select max(t0.updtime) from o_order t0");
 
-    Timestamp maxNotNew = Ebean.find(Order.class)
+    Timestamp maxNotNew = DB.find(Order.class)
       .select("max(updtime)")
       .where().ne("status", Order.Status.NEW)
       .findSingleAttribute();
@@ -284,7 +283,7 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<OrderDetail> query = Ebean.find(OrderDetail.class)
+    Query<OrderDetail> query = DB.find(OrderDetail.class)
       .select("max(orderQty)");
 
     Integer maxOrderQty = query.findSingleAttribute();
@@ -299,7 +298,7 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<OrderDetail> query = Ebean.find(OrderDetail.class)
+    Query<OrderDetail> query = DB.find(OrderDetail.class)
       .select("min(orderQty)");
 
     Integer minOrderQty = query.findSingleAttribute();
@@ -314,7 +313,7 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .select("max(lastName)");
 
     String maxName = query.findSingleAttribute();
@@ -329,7 +328,7 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .select("min(firstName)");
 
     String minName = query.findSingleAttribute();
@@ -345,7 +344,7 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .select("count(lastName)");
 
     Long count = query.findSingleAttribute();
@@ -360,7 +359,7 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .select("count(distinct lastName)");
 
     Long count = query.findSingleAttribute();
@@ -375,17 +374,17 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     String maxLastName =
-      Ebean.find(Contact.class)
+      DB.find(Contact.class)
         .select("max(lastName)")
         .where().isNull("phone")
         .findSingleAttribute();
 
     assertThat(maxLastName).isNotNull();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select max(t0.last_name) from contact t0");
   }
 
@@ -394,17 +393,17 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Long count =
-      Ebean.find(Contact.class)
+      DB.find(Contact.class)
         .select("count(distinct lastName)")
         .where().isEmpty("notes")
         .findSingleAttribute();
 
     assertThat(count).isNotNull();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select count(distinct t0.last_name) from contact t0 where not exists (select 1 from contact_note x where x.contact_id = t0.id)");
   }
 
@@ -413,11 +412,11 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<String> names =
 
-      Ebean.find(Contact.class)
+      DB.find(Contact.class)
         .select(concat("lastName",", ","firstName"))
         .where().isNull("phone")
         .order().asc("lastName")
@@ -425,7 +424,7 @@ public class TestAggregationCount extends BaseTestCase {
 
     assertThat(names).isNotEmpty();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select " + concat("t0.last_name",", ","t0.first_name") + " from contact t0 where t0.phone is null order by t0.last_name");
   }
 
@@ -434,11 +433,11 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<String> names =
 
-      Ebean.find(Contact.class)
+      DB.find(Contact.class)
         .select(concat("updtime",", ","firstName")+"::String")
         .where().isNull("phone")
         .order().asc("lastName")
@@ -446,7 +445,7 @@ public class TestAggregationCount extends BaseTestCase {
 
     assertThat(names).isNotEmpty();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select " + concat("t0.updtime",", ","t0.first_name") + " from contact t0");
   }
 
@@ -455,18 +454,18 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Instant instant =
 
-      Ebean.find(Contact.class)
+      DB.find(Contact.class)
         .select("max(updtime)::Instant")
         .where().isNull("phone")
         .findSingleAttribute();
 
     assertThat(instant).isNotNull();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select max(t0.updtime) from contact t0 where t0.phone is null");
   }
 
@@ -476,11 +475,11 @@ public class TestAggregationCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Contact> contacts =
 
-      Ebean.find(Contact.class)
+      DB.find(Contact.class)
         .select("email, " + concat("lastName",", ","firstName") + " as lastName")
         .where().isNull("phone")
         .order().asc("lastName")
@@ -493,7 +492,7 @@ public class TestAggregationCount extends BaseTestCase {
       assertThat(lastName).contains(", ");
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertSql(sql.get(0)).contains("select t0.id, t0.email, " + concat("t0.last_name",", ","t0.first_name") + " lastName from contact t0 where t0.phone is null order by t0.last_name; --bind()");
   }
 
diff --git a/ebean-core/src/test/java/org/tests/query/autotune/TestAutoTuneProfiling.java b/ebean-test/src/test/java/org/tests/query/autotune/TestAutoTuneProfiling.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/query/autotune/TestAutoTuneProfiling.java
rename to ebean-test/src/test/java/org/tests/query/autotune/TestAutoTuneProfiling.java
index 65ccbc893..2595c5bfb 100644
--- a/ebean-core/src/test/java/org/tests/query/autotune/TestAutoTuneProfiling.java
+++ b/ebean-test/src/test/java/org/tests/query/autotune/TestAutoTuneProfiling.java
@@ -3,20 +3,16 @@ package org.tests.query.autotune;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.ProfileLocation;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.tests.model.basic.Address;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.OrderDetail;
-import org.tests.model.basic.ResetBasicData;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 import java.util.Random;
 
 public class TestAutoTuneProfiling extends BaseTestCase {
 
-  @Ignore
+  @Disabled
   @Test
   public void test() {
 
@@ -117,7 +113,7 @@ public class TestAutoTuneProfiling extends BaseTestCase {
 
   private static void collectUsage() {
 
-    DB.getDefault().getAutoTune().collectProfiling();
+    DB.getDefault().autoTune().collectProfiling();
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/query/cache/Acl.java b/ebean-test/src/test/java/org/tests/query/cache/Acl.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/query/cache/Acl.java
rename to ebean-test/src/test/java/org/tests/query/cache/Acl.java
diff --git a/ebean-core/src/test/java/org/tests/query/cache/AclContainerRelation.java b/ebean-test/src/test/java/org/tests/query/cache/AclContainerRelation.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/query/cache/AclContainerRelation.java
rename to ebean-test/src/test/java/org/tests/query/cache/AclContainerRelation.java
index 9038bb56f..53d8f95e8 100644
--- a/ebean-core/src/test/java/org/tests/query/cache/AclContainerRelation.java
+++ b/ebean-test/src/test/java/org/tests/query/cache/AclContainerRelation.java
@@ -1,10 +1,6 @@
 package org.tests.query.cache;
 
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 import javax.validation.constraints.NotNull;
 
 @Entity
@@ -45,4 +41,4 @@ public class AclContainerRelation {
 		this.aclEntry = aclEntry;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/ebean-core/src/test/java/org/tests/query/cache/Contract.java b/ebean-test/src/test/java/org/tests/query/cache/Contract.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/query/cache/Contract.java
rename to ebean-test/src/test/java/org/tests/query/cache/Contract.java
index 795fbb466..344a09be6 100644
--- a/ebean-core/src/test/java/org/tests/query/cache/Contract.java
+++ b/ebean-test/src/test/java/org/tests/query/cache/Contract.java
@@ -1,12 +1,7 @@
 package org.tests.query.cache;
 
 import javax.annotation.Nonnull;
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.OneToMany;
+import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/ebean-core/src/test/java/org/tests/query/cache/ContractCosts.java b/ebean-test/src/test/java/org/tests/query/cache/ContractCosts.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/query/cache/ContractCosts.java
rename to ebean-test/src/test/java/org/tests/query/cache/ContractCosts.java
diff --git a/ebean-core/src/test/java/org/tests/query/cache/Main1.java b/ebean-test/src/test/java/org/tests/query/cache/Main1.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/query/cache/Main1.java
rename to ebean-test/src/test/java/org/tests/query/cache/Main1.java
diff --git a/ebean-core/src/test/java/org/tests/query/cache/Main2.java b/ebean-test/src/test/java/org/tests/query/cache/Main2.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/query/cache/Main2.java
rename to ebean-test/src/test/java/org/tests/query/cache/Main2.java
index 56a7ee0b1..48d513999 100644
--- a/ebean-core/src/test/java/org/tests/query/cache/Main2.java
+++ b/ebean-test/src/test/java/org/tests/query/cache/Main2.java
@@ -1,12 +1,12 @@
 package org.tests.query.cache;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 
 public class Main2 {
 
   public static void main(String[] args) {
     TestDistinct test = new TestDistinct();
-    Ebean.find(ContractCosts.class).where()
+    DB.find(ContractCosts.class).where()
     .in("position.contract.aclEntries.aclEntry.id",1L, 2L, 3L).findList(); // <-- will fix some cache issue?
     test.testMissingUnique();
 
diff --git a/ebean-core/src/test/java/org/tests/query/cache/Position.java b/ebean-test/src/test/java/org/tests/query/cache/Position.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/query/cache/Position.java
rename to ebean-test/src/test/java/org/tests/query/cache/Position.java
index 3d1060fd4..288582d0d 100644
--- a/ebean-core/src/test/java/org/tests/query/cache/Position.java
+++ b/ebean-test/src/test/java/org/tests/query/cache/Position.java
@@ -1,10 +1,6 @@
 package org.tests.query.cache;
 
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "e_position")
diff --git a/ebean-core/src/test/java/org/tests/query/cache/TestDistinct.java b/ebean-test/src/test/java/org/tests/query/cache/TestDistinct.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/query/cache/TestDistinct.java
rename to ebean-test/src/test/java/org/tests/query/cache/TestDistinct.java
index e67c2d0ea..4dc9702fe 100644
--- a/ebean-core/src/test/java/org/tests/query/cache/TestDistinct.java
+++ b/ebean-test/src/test/java/org/tests/query/cache/TestDistinct.java
@@ -1,9 +1,9 @@
 package org.tests.query.cache;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.ExpressionList;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.UUID;
@@ -18,9 +18,9 @@ public class TestDistinct extends BaseTestCase {
   @Test
   public void testMissingUnique() {
     Acl acl = new Acl("1");
-    Ebean.save(acl);
+    DB.save(acl);
     Acl acl2 = new Acl("2");
-    Ebean.save(acl2);
+    DB.save(acl2);
     Contract contract = new Contract();
     AclContainerRelation rel1 = new AclContainerRelation();
     rel1.setAclEntry(acl);
@@ -33,10 +33,10 @@ public class TestDistinct extends BaseTestCase {
     Position pos = new Position();
     pos.setContract(contract);
     contract.getPositions().add(pos);
-    Ebean.save(contract);
+    DB.save(contract);
     ContractCosts cost = new ContractCosts();
     cost.setPosition(pos);
-    Ebean.save(cost);
+    DB.save(cost);
 
     //costsQuery(acl.getId(), acl2.getId()).findCount();
 
@@ -50,10 +50,10 @@ public class TestDistinct extends BaseTestCase {
   }
 
   public ExpressionList<Position> positionsQuery(final Long aclId) {
-    return Ebean.find(Position.class).where().eq("contract.aclEntries.aclEntry.id", aclId);
+    return DB.find(Position.class).where().eq("contract.aclEntries.aclEntry.id", aclId);
   }
 
   public ExpressionList<ContractCosts> costsQuery(final Long... aclId) {
-    return Ebean.find(ContractCosts.class).where().in("position.contract.aclEntries.aclEntry.id", aclId);
+    return DB.find(ContractCosts.class).where().in("position.contract.aclEntries.aclEntry.id", aclId);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/query/cancel/EBasicDto.java b/ebean-test/src/test/java/org/tests/query/cancel/EBasicDto.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/query/cancel/EBasicDto.java
rename to ebean-test/src/test/java/org/tests/query/cancel/EBasicDto.java
diff --git a/ebean-core/src/test/java/org/tests/query/cancel/SlowDownEBasic.java b/ebean-test/src/test/java/org/tests/query/cancel/SlowDownEBasic.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/query/cancel/SlowDownEBasic.java
rename to ebean-test/src/test/java/org/tests/query/cancel/SlowDownEBasic.java
index 68d6c038b..bace1ccb9 100644
--- a/ebean-core/src/test/java/org/tests/query/cancel/SlowDownEBasic.java
+++ b/ebean-test/src/test/java/org/tests/query/cancel/SlowDownEBasic.java
@@ -1,14 +1,13 @@
 package org.tests.query.cancel;
 
+import io.ebean.DB;
+import io.ebean.Transaction;
+import org.h2.api.Trigger;
+
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.sql.Statement;
 
-import org.h2.api.Trigger;
-
-import io.ebean.DB;
-import io.ebean.Transaction;
-
 /**
  * Class to artificially slow down selects on 'e_basic' table
  */
@@ -47,7 +46,7 @@ public class SlowDownEBasic implements Trigger {
       return;
     }
     triggerInstalled = true;
-    try (Transaction txn = DB.beginTransaction(); Statement stmt = txn.getConnection().createStatement()) {
+    try (Transaction txn = DB.beginTransaction(); Statement stmt = txn.connection().createStatement()) {
 
       stmt.execute("CREATE TRIGGER SLOW_DOWN_E_BASIC BEFORE SELECT ON e_basic " + "CALL \""
           + SlowDownEBasic.class.getName() + "\"");
diff --git a/ebean-core/src/test/java/org/tests/query/cancel/SqlQueryCancelTest.java b/ebean-test/src/test/java/org/tests/query/cancel/SqlQueryCancelTest.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/query/cancel/SqlQueryCancelTest.java
rename to ebean-test/src/test/java/org/tests/query/cancel/SqlQueryCancelTest.java
index 40818cc91..eb065149e 100644
--- a/ebean-core/src/test/java/org/tests/query/cancel/SqlQueryCancelTest.java
+++ b/ebean-test/src/test/java/org/tests/query/cancel/SqlQueryCancelTest.java
@@ -1,9 +1,13 @@
 package org.tests.query.cancel;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import io.ebean.*;
+import io.ebean.annotation.ForPlatform;
+import io.ebean.annotation.Platform;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.EBasic;
 
+import javax.persistence.PersistenceException;
 import java.sql.SQLException;
 import java.util.UUID;
 import java.util.concurrent.ExecutionException;
@@ -11,20 +15,9 @@ import java.util.concurrent.Future;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-import javax.persistence.PersistenceException;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.tests.model.basic.EBasic;
-
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.DtoQuery;
-import io.ebean.Query;
-import io.ebean.QueryIterator;
-import io.ebean.SqlQuery;
-import io.ebean.annotation.ForPlatform;
-import io.ebean.annotation.Platform;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 /**
  * Tests, if all kind of queries are cancelable. There are two ways how to
@@ -36,7 +29,7 @@ import io.ebean.annotation.Platform;
  * query.cancel();
  * query.findList();
  * </pre>
- *
+ * <p>
  * The query was caneled before executing. In this case we do hit the DB driver
  * <br/>
  * <br/>
@@ -50,12 +43,12 @@ import io.ebean.annotation.Platform;
  *     ...finding            query.cancel();
  *      ...JDBC-Exception
  * </pre>
- *
+ * <p>
  * The test tries to simulate a slow query by installing the
  * {@link SlowDownEBasic} 'SELECT' trigger. The trigger can be configured to
  * wait 3 * <code>timing</code> ms and a second thread will cancel the query in
  * <code>timing</code> ms.
- *
+ * <p>
  * in this case, we expect a JDBC exception from the driver. <br/>
  * <br/>
  * NOTE:<br/>
@@ -64,19 +57,18 @@ import io.ebean.annotation.Platform;
  * queries like findCount or findOne, because they only return one row.
  *
  * @author Roland Praml, FOCONIS AG
- *
  */
 public class SqlQueryCancelTest extends BaseTestCase {
 
   private final int timing = 20;
 
-  @BeforeClass
+  @BeforeAll
   public static void setupTestData() throws SQLException {
     for (int i = 0; i < 128; i++) {
       EBasic model = new EBasic("Basic " + i);
       DB.save(model);
     }
-    if (Platform.H2.equals(DB.getDefault().getPlatform())) {
+    if (Platform.H2.equals(DB.getDefault().platform())) {
       SlowDownEBasic.setSelectWaitMillis(0);
     }
   }
@@ -85,7 +77,8 @@ public class SqlQueryCancelTest extends BaseTestCase {
   public void cancelSqlQueryAtBegin() throws SQLException {
     doCancelSqlAtBegin(SqlQuery::findList);
     doCancelSqlAtBegin(SqlQuery::findOne);
-    doCancelSqlAtBegin(q -> q.findEach(e -> {}));
+    doCancelSqlAtBegin(q -> q.findEach(e -> {
+    }));
     doCancelSqlAtBegin(q -> q.findEachWhile(e -> true));
   }
 
@@ -96,7 +89,8 @@ public class SqlQueryCancelTest extends BaseTestCase {
     doCancelSqlDuringRun(SqlQuery::findList);
     // doCancelSqlDuringRun(q -> q.setMaxRows(1).findOne());
     // findOne cannot be tested, as H2 does the cancel check every 128 rows only
-    doCancelSqlDuringRun(q -> q.findEach(e -> {}));
+    doCancelSqlDuringRun(q -> q.findEach(e -> {
+    }));
     doCancelSqlDuringRun(q -> q.findEachWhile(e -> true));
   }
 
@@ -118,9 +112,10 @@ public class SqlQueryCancelTest extends BaseTestCase {
     doCancelOrmAtBegin(q -> q.select("name").findSingleAttribute());
     doCancelOrmAtBegin(q -> q.select("name").findSingleAttributeList());
     doCancelOrmAtBegin(Query::findStream);
-   //  testDuringRun(Query::findVersions);
+    //  testDuringRun(Query::findVersions);
     // EBasic has no history support, but it should work if @History is added
-    doCancelOrmAtBegin(q -> q.findEach(e -> {}));
+    doCancelOrmAtBegin(q -> q.findEach(e -> {
+    }));
     doCancelOrmAtBegin(q -> q.findEachWhile(e -> true));
   }
 
@@ -143,9 +138,10 @@ public class SqlQueryCancelTest extends BaseTestCase {
     doCancelOrmDuringRun(q -> q.select("name").findSingleAttribute());
     doCancelOrmDuringRun(q -> q.select("name").findSingleAttributeList());
     doCancelOrmDuringRun(Query::findStream);
-   //  testDuringRun(Query::findVersions);
+    //  testDuringRun(Query::findVersions);
     // EBasic has no history support, but it should work if @History is added
-    doCancelOrmDuringRun(q -> q.findEach(e -> {}));
+    doCancelOrmDuringRun(q -> q.findEach(e -> {
+    }));
     doCancelOrmDuringRun(q -> q.findEachWhile(e -> true));
   }
 
@@ -161,7 +157,7 @@ public class SqlQueryCancelTest extends BaseTestCase {
 
     // We might have 100 entities in a buffer. So we must iterate through all.
     assertThatThrownBy(() -> {
-      while(iter.hasNext()) iter.next();
+      while (iter.hasNext()) iter.next();
     })
       .isInstanceOf(PersistenceException.class)
       .hasMessageContaining("Query was cancelled");
@@ -174,7 +170,8 @@ public class SqlQueryCancelTest extends BaseTestCase {
     doCancelOrmDtoAtBegin(DtoQuery::findList);
     doCancelOrmDtoAtBegin(DtoQuery::findOne);
     doCancelOrmDtoAtBegin(DtoQuery::findStream);
-    doCancelOrmDtoAtBegin(q -> q.findEach(e -> {}));
+    doCancelOrmDtoAtBegin(q -> q.findEach(e -> {
+    }));
     doCancelOrmDtoAtBegin(q -> q.findEachWhile(e -> true));
   }
 
@@ -187,23 +184,27 @@ public class SqlQueryCancelTest extends BaseTestCase {
     // doCancelOrmDtoDuringRun(q -> q.setMaxRows(1).findOne());
     // findOne cannot be tested, as H2 does the cancel check every 128 rows only
     doCancelOrmDtoDuringRun(DtoQuery::findStream);
-    doCancelOrmDtoDuringRun(q -> q.findEach(e -> {}));
+    doCancelOrmDtoDuringRun(q -> q.findEach(e -> {
+    }));
     doCancelOrmDtoDuringRun(q -> q.findEachWhile(e -> true));
   }
 
   @Test
-  public void cancelOrmDtoDuringIterate() throws SQLException {
-
+  public void cancelOrmDtoDuringIterate() {
     DtoQuery<EBasicDto> query = DB.find(EBasic.class).select("id,status").asDto(EBasicDto.class);
 
     QueryIterator<EBasicDto> iter = query.findIterate();
     assertThat(iter.hasNext()).isTrue();
     query.cancel();
-    assertThat(iter.next()).isNotNull();
+    if (isMariaDB()) {
+      assertThrows(PersistenceException.class, iter::next);
+    } else {
+      assertThat(iter.next()).isNotNull();
+    }
 
     // We might have 100 entities in a buffer. So we must iterate through all.
     assertThatThrownBy(() -> {
-      while(iter.hasNext()) iter.next();
+      while (iter.hasNext()) iter.next();
     })
       .isInstanceOf(PersistenceException.class)
       .hasMessageContaining("Query was cancelled");
@@ -216,7 +217,8 @@ public class SqlQueryCancelTest extends BaseTestCase {
     doCancelSqlDtoAtBegin(DtoQuery::findList);
     doCancelSqlDtoAtBegin(DtoQuery::findOne);
     doCancelSqlDtoAtBegin(DtoQuery::findStream);
-    doCancelSqlDtoAtBegin(q -> q.findEach(e -> {}));
+    doCancelSqlDtoAtBegin(q -> q.findEach(e -> {
+    }));
     doCancelSqlDtoAtBegin(q -> q.findEachWhile(e -> true));
   }
 
@@ -229,7 +231,8 @@ public class SqlQueryCancelTest extends BaseTestCase {
     // doCancelSqlDtoDuringRun(q -> q.setMaxRows(1).findOne());
     // findOne cannot be tested, as H2 does the cancel check every 128 rows only
     doCancelSqlDtoDuringRun(DtoQuery::findStream);
-    doCancelSqlDtoDuringRun(q -> q.findEach(e -> {}));
+    doCancelSqlDtoDuringRun(q -> q.findEach(e -> {
+    }));
     doCancelSqlDtoDuringRun(q -> q.findEachWhile(e -> true));
   }
 
@@ -245,7 +248,7 @@ public class SqlQueryCancelTest extends BaseTestCase {
 
     // We might have 100 entities in a buffer. So we must iterate through all.
     assertThatThrownBy(() -> {
-      while(iter.hasNext()) iter.next();
+      while (iter.hasNext()) iter.next();
     })
       .isInstanceOf(PersistenceException.class)
       .hasMessageContaining("Query was cancelled");
@@ -255,8 +258,8 @@ public class SqlQueryCancelTest extends BaseTestCase {
     SqlQuery query = DB.sqlQuery("select * from e_basic");
     query.cancel();
     assertThatThrownBy(() -> test.accept(query))
-        .isInstanceOf(PersistenceException.class)
-        .hasMessageContaining("Query was cancelled");
+      .isInstanceOf(PersistenceException.class)
+      .hasMessageContaining("Query was cancelled");
   }
 
   private void doCancelSqlDuringRun(Consumer<SqlQuery> test) throws SQLException {
@@ -265,16 +268,16 @@ public class SqlQueryCancelTest extends BaseTestCase {
     SqlQuery query = DB.sqlQuery("select * from e_basic");
     executeDelayed(query::cancel);
     assertThatThrownBy(() -> test.accept(query))
-        .isInstanceOf(PersistenceException.class)
-        .hasCauseInstanceOf(org.h2.jdbc.JdbcSQLTimeoutException.class);
+      .isInstanceOf(PersistenceException.class)
+      .hasCauseInstanceOf(org.h2.jdbc.JdbcSQLTimeoutException.class);
   }
 
   private void doCancelOrmAtBegin(Consumer<Query<EBasic>> test) throws SQLException {
     Query<EBasic> query = DB.find(EBasic.class);
     query.cancel();
     assertThatThrownBy(() -> test.accept(query))
-        .isInstanceOf(PersistenceException.class)
-        .hasMessageContaining("Query was cancelled");
+      .isInstanceOf(PersistenceException.class)
+      .hasMessageContaining("Query was cancelled");
   }
 
   private void doCancelOrmDuringRun(Consumer<Query<EBasic>> test) throws SQLException {
@@ -285,8 +288,8 @@ public class SqlQueryCancelTest extends BaseTestCase {
     Query<EBasic> query = DB.find(EBasic.class);
     executeDelayed(query::cancel);
     assertThatThrownBy(() -> test.accept(query))
-        .isInstanceOf(PersistenceException.class)
-        .hasCauseInstanceOf(org.h2.jdbc.JdbcSQLTimeoutException.class);
+      .isInstanceOf(PersistenceException.class)
+      .hasCauseInstanceOf(org.h2.jdbc.JdbcSQLTimeoutException.class);
   }
 
   private void doCancelOrmFutureDuringRun(Function<Query<EBasic>, Future<?>> test) throws SQLException, InterruptedException, ExecutionException {
@@ -310,8 +313,8 @@ public class SqlQueryCancelTest extends BaseTestCase {
     DtoQuery<EBasicDto> query = DB.find(EBasic.class).select("id,status").asDto(EBasicDto.class);
     query.cancel();
     assertThatThrownBy(() -> test.accept(query))
-        .isInstanceOf(PersistenceException.class)
-        .hasMessageContaining("Query was cancelled");
+      .isInstanceOf(PersistenceException.class)
+      .hasMessageContaining("Query was cancelled");
   }
 
   private void doCancelOrmDtoDuringRun(Consumer<DtoQuery<EBasicDto>> test) throws SQLException {
@@ -321,16 +324,16 @@ public class SqlQueryCancelTest extends BaseTestCase {
     DtoQuery<EBasicDto> query = DB.find(EBasic.class).select("id,status").asDto(EBasicDto.class);
     executeDelayed(query::cancel);
     assertThatThrownBy(() -> test.accept(query))
-        .isInstanceOf(PersistenceException.class)
-        .hasCauseInstanceOf(org.h2.jdbc.JdbcSQLTimeoutException.class);
+      .isInstanceOf(PersistenceException.class)
+      .hasCauseInstanceOf(org.h2.jdbc.JdbcSQLTimeoutException.class);
   }
 
   private void doCancelSqlDtoAtBegin(Consumer<DtoQuery<EBasicDto>> test) throws SQLException {
     DtoQuery<EBasicDto> query = DB.findDto(EBasicDto.class, "select id, status from e_basic");
     query.cancel();
     assertThatThrownBy(() -> test.accept(query))
-        .isInstanceOf(PersistenceException.class)
-        .hasMessageContaining("Query was cancelled");
+      .isInstanceOf(PersistenceException.class)
+      .hasMessageContaining("Query was cancelled");
   }
 
   private void doCancelSqlDtoDuringRun(Consumer<DtoQuery<EBasicDto>> test) throws SQLException {
@@ -340,8 +343,8 @@ public class SqlQueryCancelTest extends BaseTestCase {
     DtoQuery<EBasicDto> query = DB.findDto(EBasicDto.class, "select id, status from e_basic");
     executeDelayed(query::cancel);
     assertThatThrownBy(() -> test.accept(query))
-        .isInstanceOf(PersistenceException.class)
-        .hasCauseInstanceOf(org.h2.jdbc.JdbcSQLTimeoutException.class);
+      .isInstanceOf(PersistenceException.class)
+      .hasCauseInstanceOf(org.h2.jdbc.JdbcSQLTimeoutException.class);
   }
 
   private void executeDelayed(Runnable r) throws SQLException {
diff --git a/ebean-test/src/test/java/org/tests/query/embedded/TestFilteringByEmbeddedInJoinedTable.java b/ebean-test/src/test/java/org/tests/query/embedded/TestFilteringByEmbeddedInJoinedTable.java
new file mode 100644
index 000000000..9b449cf4d
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/query/embedded/TestFilteringByEmbeddedInJoinedTable.java
@@ -0,0 +1,74 @@
+package org.tests.query.embedded;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.ExpressionList;
+import org.junit.jupiter.api.Test;
+import org.tests.model.embedded.EEmbDatePeriod;
+import org.tests.model.embedded.EEmbInner;
+import org.tests.model.embedded.EEmbOuter;
+
+import java.util.Date;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Test that selecting A and filtering on 'B.C=some_value' will correctly create join on table for B.
+ * Model:
+ * - Bean A has relation to bean B
+ * - Bean B has an embedded property C
+ */
+public class TestFilteringByEmbeddedInJoinedTable extends BaseTestCase {
+
+  private EEmbOuter createOuter(String nomeOuter, Date date1, Date date2) {
+    EEmbOuter outer1 = new EEmbOuter();
+    outer1.setNomeOuter(nomeOuter);
+
+    EEmbDatePeriod eEmbDatePeriod = new EEmbDatePeriod();
+    eEmbDatePeriod.setDate1(date1);
+    eEmbDatePeriod.setDate2(date2);
+    outer1.setDatePeriod(eEmbDatePeriod);
+
+    DB.save(outer1);
+    return outer1;
+  }
+
+  @Test
+  public void testOuterTableJoined() {
+
+    EEmbOuter outer1 = createOuter("outer1", new Date(11111), new Date(12222));
+    // Unused outer2 just to populate the DB
+    EEmbOuter outer2 = createOuter("outer2", new Date(21111), new Date(22222));
+    assertThat(outer2).isNotNull();
+
+    EEmbOuter outer3 = createOuter("outer3", new Date(31111), new Date(32222));
+
+
+    EEmbInner inner1 = new EEmbInner();
+    inner1.setOuter(outer1);
+    inner1.setNomeInner("inner1-1");
+    DB.save(inner1);
+
+    EEmbInner inner2 = new EEmbInner();
+    // Setting outer1 also here
+    inner2.setOuter(outer1);
+    inner2.setNomeInner("inner2-1");
+    DB.save(inner2);
+
+    EEmbInner inner3 = new EEmbInner();
+    inner3.setOuter(outer3);
+    inner3.setNomeInner("inner3-3");
+    DB.save(inner3);
+
+    ExpressionList<EEmbInner> el = DB.find(EEmbInner.class).where()
+      .eq("outer.datePeriod.date1", new Date(11111));
+    List<EEmbInner> list = el.findList();
+
+    assertThat(list).hasSize(2);
+  }
+}
+
+
+
+
diff --git a/ebean-core/src/test/java/org/tests/query/embedded/TestMultipleEmbeddedLoading.java b/ebean-test/src/test/java/org/tests/query/embedded/TestMultipleEmbeddedLoading.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/query/embedded/TestMultipleEmbeddedLoading.java
rename to ebean-test/src/test/java/org/tests/query/embedded/TestMultipleEmbeddedLoading.java
index b6ca2d3c0..9291cde2e 100644
--- a/ebean-core/src/test/java/org/tests/query/embedded/TestMultipleEmbeddedLoading.java
+++ b/ebean-test/src/test/java/org/tests/query/embedded/TestMultipleEmbeddedLoading.java
@@ -1,21 +1,21 @@
 package org.tests.query.embedded;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.cache.ServerCache;
 import io.ebean.cache.ServerCacheManager;
 import io.ebean.cache.ServerCacheStatistics;
+import org.junit.jupiter.api.Test;
 import org.tests.model.embedded.EAddress;
 import org.tests.model.embedded.EInvoice;
 import org.tests.model.embedded.EInvoice.State;
-import org.junit.Test;
 
 import java.util.Date;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestMultipleEmbeddedLoading extends BaseTestCase {
 
@@ -40,9 +40,9 @@ public class TestMultipleEmbeddedLoading extends BaseTestCase {
     invoice.setBillAddress(bill);
 
     // act: save and fetch
-    Ebean.save(invoice);
+    DB.save(invoice);
 
-    EInvoice invoice2 = Ebean.find(EInvoice.class, invoice.getId());
+    EInvoice invoice2 = DB.find(EInvoice.class, invoice.getId());
 
     // assert fetched bean populated as expected
     assertEquals(invoice.getId(), invoice2.getId());
@@ -54,18 +54,18 @@ public class TestMultipleEmbeddedLoading extends BaseTestCase {
     // act: only update one of the embedded fields
     invoice2.getBillAddress().setStreet("3 Pineapple St");
     // bean should be dirty
-    Ebean.save(invoice2);
+    DB.save(invoice2);
 
     awaitL2Cache();
 
-    EInvoice invoice3 = Ebean.find(EInvoice.class, invoice.getId());
+    EInvoice invoice3 = DB.find(EInvoice.class, invoice.getId());
 
     // assert field has updated value
     assertEquals("3 Pineapple St", invoice3.getBillAddress().getStreet());
 
 
     // fetch a partial
-    EInvoice invoicePartial = Ebean.find(EInvoice.class)
+    EInvoice invoicePartial = DB.find(EInvoice.class)
       .select("state, date")
       .where().idEq(invoice.getId())
       .findOne();
@@ -76,28 +76,28 @@ public class TestMultipleEmbeddedLoading extends BaseTestCase {
     assertNotNull(billAddress);
     assertEquals("3 Pineapple St", billAddress.getStreet());
 
-    EbeanServer server = Ebean.getServer(null);
-    ServerCacheManager serverCacheManager = server.getServerCacheManager();
+    Database server = DB.getDefault();
+    ServerCacheManager serverCacheManager = server.cacheManager();
 
     // get cache, clear the cache and statistics
-    ServerCache beanCache = serverCacheManager.getBeanCache(EInvoice.class);
+    ServerCache beanCache = serverCacheManager.beanCache(EInvoice.class);
     beanCache.clear();
-    beanCache.getStatistics(true);
+    beanCache.statistics(true);
 
     // fetch and load the cache
-    EInvoice invoice4 = Ebean.find(EInvoice.class, invoice.getId());
+    EInvoice invoice4 = DB.find(EInvoice.class, invoice.getId());
     assertNotNull(invoice4);
 
-    ServerCacheStatistics statistics = beanCache.getStatistics(false);
+    ServerCacheStatistics statistics = beanCache.statistics(false);
 
     assertEquals(1, statistics.getSize());
     assertEquals(0, statistics.getHitCount());
 
     // fetch out of the cache this time
-    EInvoice invoice5 = Ebean.find(EInvoice.class, invoice.getId());
+    EInvoice invoice5 = DB.find(EInvoice.class, invoice.getId());
     assertNotNull(invoice5);
 
-    statistics = beanCache.getStatistics(false);
+    statistics = beanCache.statistics(false);
     assertEquals(1, statistics.getSize());
     assertEquals(1, statistics.getHitCount());
 
diff --git a/ebean-core/src/test/java/org/tests/query/finder/TestCustomerFinder.java b/ebean-test/src/test/java/org/tests/query/finder/TestCustomerFinder.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/query/finder/TestCustomerFinder.java
rename to ebean-test/src/test/java/org/tests/query/finder/TestCustomerFinder.java
index d36e36b51..85e43db88 100644
--- a/ebean-core/src/test/java/org/tests/query/finder/TestCustomerFinder.java
+++ b/ebean-test/src/test/java/org/tests/query/finder/TestCustomerFinder.java
@@ -3,15 +3,9 @@ package org.tests.query.finder;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Transaction;
-import io.ebean.meta.MetaQueryMetric;
-import io.ebean.meta.MetaQueryPlan;
-import io.ebean.meta.MetaTimedMetric;
-import io.ebean.meta.QueryPlanInit;
-import io.ebean.meta.QueryPlanRequest;
-import io.ebean.meta.ServerMetrics;
-import io.ebean.meta.SortMetric;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.meta.*;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasic;
 import org.tests.model.basic.ResetBasicData;
@@ -19,7 +13,7 @@ import org.tests.model.basic.ResetBasicData;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestCustomerFinder extends BaseTestCase {
 
@@ -31,7 +25,7 @@ public class TestCustomerFinder extends BaseTestCase {
     runQueries();
 
     StringBuilder buffer0 = new StringBuilder();
-    DB.getDefault().getMetaInfoManager()
+    DB.getDefault().metaInfo()
       .collectMetricsAsJson()
       .withHeader(false)
       .write(buffer0);
@@ -45,7 +39,7 @@ public class TestCustomerFinder extends BaseTestCase {
     runQueries();
 
     StringBuilder buffer1 = new StringBuilder();
-    DB.getDefault().getMetaInfoManager()
+    DB.getDefault().metaInfo()
       .collectMetricsAsJson()
       .withHeader(false)
       .write(buffer1);
@@ -83,7 +77,7 @@ public class TestCustomerFinder extends BaseTestCase {
     assertThat(customer.getId()).isEqualTo(customer1.getId());
     assertThat(customer.getName()).isEqualTo(customer1.getName());
 
-    assertThat(Customer.find.db().getName()).isEqualTo(DB.getDefault().getName());
+    assertThat(Customer.find.db().name()).isEqualTo(DB.getDefault().name());
   }
 
   @Test
@@ -107,14 +101,14 @@ public class TestCustomerFinder extends BaseTestCase {
     try {
       Customer.find.currentTransaction().setBatchMode(true);
 
-      LoggedSqlCollector.start();
+      LoggedSql.start();
       EBasic b = new EBasic("junk");
       DB.save(b);
 
-      assertTrue(LoggedSqlCollector.current().isEmpty());
+      assertTrue(LoggedSql.collect().isEmpty());
       Customer.find.flush();
 
-      List<String> sql = LoggedSqlCollector.stop();
+      List<String> sql = LoggedSql.stop();
       assertSql(sql.get(0)).contains("insert into e_basic");
     } finally {
       transaction.end();
@@ -177,7 +171,7 @@ public class TestCustomerFinder extends BaseTestCase {
     QueryPlanInit init0 = new QueryPlanInit();
     init0.setAll(true);
     init0.thresholdMicros(2);
-    final List<MetaQueryPlan> plans = server().getMetaInfoManager().queryPlanInit(init0);
+    final List<MetaQueryPlan> plans = server().metaInfo().queryPlanInit(init0);
     assertThat(plans.size()).isGreaterThan(1);
 
     // the server has some plans
@@ -187,13 +181,13 @@ public class TestCustomerFinder extends BaseTestCase {
     QueryPlanInit init = new QueryPlanInit();
     init.setAll(true);
     init.thresholdMicros(1);
-    final List<MetaQueryPlan> appliedToPlans = server().getMetaInfoManager().queryPlanInit(init);
+    final List<MetaQueryPlan> appliedToPlans = server().metaInfo().queryPlanInit(init);
     assertThat(appliedToPlans.size()).isGreaterThan(4);
 
     // run queries again
     runQueries();
 
-    ServerMetrics metrics = DB.getDefault().getMetaInfoManager().collectMetrics();
+    ServerMetrics metrics = DB.getDefault().metaInfo().collectMetrics();
 
     List<MetaQueryMetric> planStats = metrics.queryMetrics();
     assertThat(planStats.size()).isGreaterThan(4);
@@ -212,7 +206,7 @@ public class TestCustomerFinder extends BaseTestCase {
     request.maxCount(1_000);
     // don't collect any more plans if used 10 secs
     request.maxTimeMillis(10_000);
-    List<MetaQueryPlan> plans0 = server().getMetaInfoManager().queryPlanCollectNow(request);
+    List<MetaQueryPlan> plans0 = server().metaInfo().queryPlanCollectNow(request);
     assertThat(plans0).isNotEmpty();
 
     for (MetaQueryPlan plan : plans) {
@@ -232,7 +226,7 @@ public class TestCustomerFinder extends BaseTestCase {
 
     runQueries();
 
-    String metricsJson = server().getMetaInfoManager()
+    String metricsJson = server().metaInfo()
       .collectMetricsAsJson()
       .withHash(true)
       .withExtraAttributes(true)
@@ -256,7 +250,7 @@ public class TestCustomerFinder extends BaseTestCase {
 
     runQueries();
 
-    String metricsJson = server().getMetaInfoManager()
+    String metricsJson = server().metaInfo()
       .collectMetricsAsJson()
       .withHash(false)
       .withExtraAttributes(false)
@@ -279,7 +273,7 @@ public class TestCustomerFinder extends BaseTestCase {
     runQueries();
 
     StringBuilder buffer = new StringBuilder();
-    server().getMetaInfoManager()
+    server().metaInfo()
       .collectMetricsAsJson()
       .withHeader(false)
       .write(buffer);
@@ -297,7 +291,7 @@ public class TestCustomerFinder extends BaseTestCase {
     runQueries();
 
     StringBuilder buffer = new StringBuilder();
-    server().getMetaInfoManager()
+    server().metaInfo()
       .collectMetricsAsJson()
       .withHeader(true)
       .write(buffer);
diff --git a/ebean-core/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterJoin.java b/ebean-test/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterJoin.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterJoin.java
rename to ebean-test/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterJoin.java
index 5d895adbc..840b3b46f 100644
--- a/ebean-core/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterJoin.java
+++ b/ebean-test/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterJoin.java
@@ -1,10 +1,10 @@
 package org.tests.query.joins;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Expr;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.basic.one2one.Wheel;
 import org.tests.model.basic.MRole;
 import org.tests.model.basic.MUser;
@@ -18,39 +18,39 @@ public class TestDisjunctWhereOuterJoin extends BaseTestCase {
   @Test
   public void test() {
 
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
 
       MRole r1 = new MRole();
       r1.setRoleName("role1B");
-      Ebean.save(r1);
+      DB.save(r1);
 
       MRole r2 = new MRole();
       r2.setRoleName("role2specialB");
-      Ebean.save(r2);
+      DB.save(r2);
 
       MRole r3 = new MRole();
       r3.setRoleName("role3B");
-      Ebean.save(r3);
+      DB.save(r3);
 
       MUser u0 = new MUser();
       u0.setUserName("user0B");
       u0.addRole(r1);
       u0.addRole(r2);
 
-      Ebean.save(u0);
+      DB.save(u0);
 
       MUser u1 = new MUser();
       u1.setUserName("user1B");
       u1.addRole(r1);
 
-      Ebean.save(u1);
+      DB.save(u1);
 
       queryOrExpression(r2.getRoleid());
 
       queryDisjunction(r2.getRoleid());
 
-      Query<MUser> query = Ebean.find(MUser.class)
+      Query<MUser> query = DB.find(MUser.class)
         .where().disjunction()
         .eq("roles.roleName", "role2specialB") // user0
         .eq("roles.roleName", "role3B") // nobody
@@ -64,13 +64,13 @@ public class TestDisjunctWhereOuterJoin extends BaseTestCase {
       assertThat(sql).contains(".role_name = ?");
 
     } finally {
-      Ebean.rollbackTransaction();
+      DB.rollbackTransaction();
     }
   }
 
   private void queryDisjunction(Integer roleid) {
 
-    Query<MUser> query = Ebean.find(MUser.class)
+    Query<MUser> query = DB.find(MUser.class)
       .where().or()
       .eq("userName", "user0B")
       .eq("roles.roleid", roleid)
@@ -85,9 +85,9 @@ public class TestDisjunctWhereOuterJoin extends BaseTestCase {
 
   @Test
   public void testSelectOneToOneDisjunction() {
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
-      Query<Wheel> query = Ebean.find(Wheel.class)
+      Query<Wheel> query = DB.find(Wheel.class)
               .select("id")
               .where().or()
               .ge("tire.id", 100)
@@ -97,13 +97,13 @@ public class TestDisjunctWhereOuterJoin extends BaseTestCase {
       String sql = sqlOf(query);
       assertThat(sql).contains("join");
     } finally {
-      Ebean.rollbackTransaction();
+      DB.rollbackTransaction();
     }
   }
 
   private void queryOrExpression(Integer roleid) {
 
-    Query<MUser> query = Ebean.find(MUser.class)
+    Query<MUser> query = DB.find(MUser.class)
       .where().or(
         Expr.eq("userName", "user0B"),
         Expr.eq("roles.roleid", roleid)
diff --git a/ebean-core/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterOnMany.java b/ebean-test/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterOnMany.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterOnMany.java
rename to ebean-test/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterOnMany.java
index 5f88152f9..c617a1a60 100644
--- a/ebean-core/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterOnMany.java
+++ b/ebean-test/src/test/java/org/tests/query/joins/TestDisjunctWhereOuterOnMany.java
@@ -1,24 +1,23 @@
 package org.tests.query.joins;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UUOne;
 import org.tests.model.basic.UUTwo;
 
 import java.util.List;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestDisjunctWhereOuterOnMany extends BaseTestCase {
 
   @Test
   public void test() {
 
-    Ebean.deleteAll(Ebean.find(UUTwo.class).select("id").findList());
-    Ebean.deleteAll(Ebean.find(UUOne.class).select("id").findList());
+    DB.deleteAll(DB.find(UUTwo.class).select("id").findList());
+    DB.deleteAll(DB.find(UUOne.class).select("id").findList());
 
     // setup
     UUOne master1 = new UUOne();
@@ -31,13 +30,13 @@ public class TestDisjunctWhereOuterOnMany extends BaseTestCase {
     UUOne master2 = new UUOne();
     master2.setName("testDisjOuter_2_name");
 
-    Ebean.save(master1);
-    Ebean.save(detail1);
-    Ebean.save(master2);
+    DB.save(master1);
+    DB.save(detail1);
+    DB.save(master2);
 
 
     // Have outer join so that "testDisjOuter_2_name" is found
-    Query<UUOne> query = Ebean.find(UUOne.class)
+    Query<UUOne> query = DB.find(UUOne.class)
       .where().disjunction()
       .eq("name", "testDisjOuter_2_name")
       .eq("comments.name", "testDisjOuter_CHILD_1")
@@ -54,8 +53,8 @@ public class TestDisjunctWhereOuterOnMany extends BaseTestCase {
     // where (t0.name = ?  or u1.name = ? ) ;
     // --bind(testDisjOuter_2_name,testDisjOuter_CHILD_1)
 
-    Assert.assertEquals(2, list.size());
-    Assert.assertEquals(2, rowCount);
+    assertEquals(2, list.size());
+    assertEquals(2, rowCount);
 
     if (isPostgres()) {
       String expectedSql = "select distinct on (t0.id) t0.id, t0.name, t0.description, t0.version from uuone t0 left join uutwo u1 on u1.master_id = t0.id where (t0.name = ? or u1.name = ?)";
diff --git a/ebean-core/src/test/java/org/tests/query/joins/TestQueryJoinManyNonRoot.java b/ebean-test/src/test/java/org/tests/query/joins/TestQueryJoinManyNonRoot.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/query/joins/TestQueryJoinManyNonRoot.java
rename to ebean-test/src/test/java/org/tests/query/joins/TestQueryJoinManyNonRoot.java
index fc2ac644f..c67d875a1 100644
--- a/ebean-core/src/test/java/org/tests/query/joins/TestQueryJoinManyNonRoot.java
+++ b/ebean-test/src/test/java/org/tests/query/joins/TestQueryJoinManyNonRoot.java
@@ -1,20 +1,17 @@
 package org.tests.query.joins;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
 import io.ebean.Query;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryJoinManyNonRoot extends BaseTestCase {
 
@@ -23,16 +20,16 @@ public class TestQueryJoinManyNonRoot extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Order> orders = Ebean.find(Order.class)
+    List<Order> orders = DB.find(Order.class)
       .select("id, status, orderDate")
       .where().gt("details.orderQty", 0)
       .findList();
 
     assertTrue(!orders.isEmpty());
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertEquals(1, loggedSql.size());
     assertTrue(loggedSql.get(0).contains("select distinct "));
     assertTrue(loggedSql.get(0).contains(" from o_order t0 join o_order_detail u1 on u1.order_id = t0.id "));
@@ -43,7 +40,7 @@ public class TestQueryJoinManyNonRoot extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> q = Ebean.find(Order.class)
+    Query<Order> q = DB.find(Order.class)
       .fetch("customer")
       .fetch("customer.contacts")
       .where().gt("id", 0).query();
@@ -55,14 +52,11 @@ public class TestQueryJoinManyNonRoot extends BaseTestCase {
     assertTrue(sql.contains("join o_customer t1 on t1.id "));
     assertTrue(sql.contains("left join contact t2 on"));
 
-    Map<Integer, Order> ordersById = Ebean.find(Order.class).setMapKey("id").where().gt("id", 0).query().findMap();
+    Map<Integer, Order> ordersById = DB.find(Order.class).setMapKey("id").where().gt("id", 0).query().findMap();
     for (Order o: list) {
       int withoutFetch = ordersById.get(o.getId()).getCustomer().getContacts().size();
       int withFetch = o.getCustomer().getContacts().size();
-      assertEquals(String.format("order.customer.contacts for order %d did not match. " +
-              "Items without fetch: %d, with fetch: %d", o.getId(), withoutFetch, withFetch),
-              withoutFetch,
-              withFetch);
+      assertEquals(withoutFetch, withFetch);
     }
 
 
@@ -81,7 +75,7 @@ public class TestQueryJoinManyNonRoot extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> q = Ebean.find(Order.class)
+    Query<Order> q = DB.find(Order.class)
       .fetch("details")
       .fetch("details.product")
       .fetch("customer")
@@ -96,7 +90,7 @@ public class TestQueryJoinManyNonRoot extends BaseTestCase {
     assertTrue(sql.contains("left join o_order_detail "));
     assertTrue(sql.contains("left join o_product "));
 
-    Assert.assertFalse(sql.contains("left join contact"));
+    assertFalse(sql.contains("left join contact"));
 
   }
 
@@ -105,7 +99,7 @@ public class TestQueryJoinManyNonRoot extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> q = Ebean.find(Order.class)
+    Query<Order> q = DB.find(Order.class)
       .fetch("customer")
       .fetch("customer.contacts")
       .fetchQuery("details")
@@ -123,8 +117,8 @@ public class TestQueryJoinManyNonRoot extends BaseTestCase {
     assertTrue(sql.contains("join o_customer t1 on t1.id "));
     assertTrue(sql.contains("left join contact "));
 
-    Assert.assertFalse(sql.contains("left join o_order_detail "));
-    Assert.assertFalse(sql.contains("left join o_product "));
+    assertFalse(sql.contains("left join o_order_detail "));
+    assertFalse(sql.contains("left join o_product "));
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/query/joins/TestQueryJoinOnFormula.java b/ebean-test/src/test/java/org/tests/query/joins/TestQueryJoinOnFormula.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/query/joins/TestQueryJoinOnFormula.java
rename to ebean-test/src/test/java/org/tests/query/joins/TestQueryJoinOnFormula.java
index 73449c398..079b41d0f 100644
--- a/ebean-core/src/test/java/org/tests/query/joins/TestQueryJoinOnFormula.java
+++ b/ebean-test/src/test/java/org/tests/query/joins/TestQueryJoinOnFormula.java
@@ -1,25 +1,24 @@
 package org.tests.query.joins;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 import org.tests.model.family.ChildPerson;
 import org.tests.model.family.ParentPerson;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Before;
-import org.junit.Test;
 
 import java.sql.Date;
 import java.util.List;
 
-import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestQueryJoinOnFormula extends BaseTestCase {
 
-
-  @Before
+  @BeforeEach
   public void init() {
     ResetBasicData.reset();
   }
@@ -27,14 +26,14 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_OrderFindIds() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Integer> orderIds = Ebean.find(Order.class)
+    List<Integer> orderIds = DB.find(Order.class)
         .where().eq("totalItems", 3)
         .findIds();
     assertThat(orderIds).hasSize(2);
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertEquals(1, loggedSql.size());
     assertThat(loggedSql.get(0)).contains(" left join (select order_id, count(*) as total_items,");
   }
@@ -42,14 +41,14 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_OrderFindList() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Order> orders = Ebean.find(Order.class)
+    List<Order> orders = DB.find(Order.class)
         .where().eq("totalItems", 3)
         .findList();
     assertThat(orders).hasSize(2);
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertEquals(1, loggedSql.size());
     assertThat(loggedSql.get(0)).contains(" left join (select order_id, count(*) as total_items,");
   }
@@ -57,14 +56,14 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_OrderFindCount() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    int orders = Ebean.find(Order.class)
+    int orders = DB.find(Order.class)
         .where().eq("totalItems", 3)
         .findCount();
     assertThat(orders).isEqualTo(2);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertEquals(1, sql.size());
     assertSql(sql.get(0)).contains("join (select order_id, count(*) as total_items,");
     assertSql(sql.get(0)).contains("select count(*) from ( select t0.id from o_order t0  left join (select order_id,");
@@ -73,9 +72,9 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_OrderFindCount_multiFormula() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    int orders = Ebean.find(Order.class)
+    int orders = DB.find(Order.class)
       .where()
       .eq("totalItems", 3)
       .gt("totalAmount", 10)
@@ -83,7 +82,7 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
 
     assertThat(orders).isEqualTo(2);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertEquals(1, sql.size());
     assertSql(sql.get(0)).contains("select count(*) from ( select t0.id from o_order t0  left join (select order_id,");
   }
@@ -91,15 +90,15 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_OrderFindSingleAttributeList() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Date> orderDates = Ebean.find(Order.class)
+    List<Date> orderDates = DB.find(Order.class)
         .select("orderDate")
         .where().eq("totalItems", 3)
         .findSingleAttributeList();
     assertThat(orderDates).hasSize(2);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertEquals(1, sql.size());
     assertSql(sql.get(0)).contains(" left join (select order_id, count(*) as total_items,");
     assertSql(sql.get(0)).contains("select t0.order_date from o_order t0");
@@ -108,9 +107,9 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_OrderFindOne() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Order order = Ebean.find(Order.class)
+    Order order = DB.find(Order.class)
         .select("totalItems")
         .where().eq("totalItems", 3)
         .setMaxRows(1)
@@ -119,7 +118,7 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
 
     assertThat(order.getTotalItems()).isEqualTo(3);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertEquals(1, sql.size());
     assertSql(sql.get(0)).contains("join (select order_id, count(*) as total_items,");
     if (isSqlServer()) {
@@ -132,13 +131,13 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_ParentPersonFindIds() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<ParentPerson> orderIds = Ebean.find(ParentPerson.class)
+    List<ParentPerson> orderIds = DB.find(ParentPerson.class)
         .where().eq("totalAge", 3)
         .findIds();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertEquals(1, loggedSql.size());
     assertThat(loggedSql.get(0)).contains("where coalesce(f2.child_age, 0) = ?; --bind(3)");
   }
@@ -146,15 +145,15 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_ParentPersonFindList() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(ParentPerson.class)
+    DB.find(ParentPerson.class)
         .select("identifier")
         //.where().eq("totalAge", 3)
         .where().eq("familyName", "foo")
         .findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertEquals(1, sql.size());
     assertSql(sql.get(0)).contains("select t0.identifier from parent_person t0 where t0.family_name = ?");
   }
@@ -162,13 +161,13 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_ParentPersonFindCount() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(ParentPerson.class)
+    DB.find(ParentPerson.class)
       .where().eq("totalAge", 3)
       .findCount();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertEquals(1, sql.size());
     assertSql(sql.get(0)).contains("where coalesce(f2.child_age, 0) = ?)");
     assertSql(sql.get(0)).contains("select count(*) from ( select t0.identifier from parent_person t0 left join (select i2.parent_identifier, count(*) as child_count");
@@ -177,14 +176,14 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_ParentPersonFindSingleAttributeList() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(ParentPerson.class)
+    DB.find(ParentPerson.class)
       .select("address")
       .where().eq("totalAge", 3)
       .findSingleAttributeList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertEquals(1, sql.size());
     assertSql(sql.get(0)).contains("select t0.address from parent_person t0 left join (select i2.parent_identifier");
     assertSql(sql.get(0)).contains("where coalesce(f2.child_age, 0) = ?; --bind(3)");
@@ -193,15 +192,15 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_ParentPersonFindOne() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(ParentPerson.class)
+    DB.find(ParentPerson.class)
       .where().eq("totalAge", 3)
       .setMaxRows(1)
       .orderById(true)
       .findOne();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertEquals(1, loggedSql.size());
     assertThat(loggedSql.get(0)).contains("where coalesce(f2.child_age, 0) = ? order by t0.identifier");
   }
@@ -209,13 +208,13 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_ChildPersonParentFindIds() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(ChildPerson.class)
+    DB.find(ChildPerson.class)
         .where().eq("parent.totalAge", 3)
         .findIds();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertEquals(1, loggedSql.size());
     assertThat(loggedSql.get(0)).contains("select t0.identifier from child_person t0 left join (select i2.parent_identifier");
     assertThat(loggedSql.get(0)).contains("where coalesce(f2.child_age, 0) = ?");
@@ -224,13 +223,13 @@ public class TestQueryJoinOnFormula extends BaseTestCase {
   @Test
   public void test_ChildPersonParentFindCount() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(ChildPerson.class)
+    DB.find(ChildPerson.class)
         .where().eq("parent.totalAge", 3)
         .findCount();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertEquals(1, loggedSql.size());
     assertThat(loggedSql.get(0)).contains("select count(*) from ( select t0.identifier");
     assertThat(loggedSql.get(0)).contains("where coalesce(f2.child_age, 0) = ?");
diff --git a/ebean-core/src/test/java/org/tests/query/joins/TestQueryJoinQueryNonRoot.java b/ebean-test/src/test/java/org/tests/query/joins/TestQueryJoinQueryNonRoot.java
similarity index 62%
rename from ebean-core/src/test/java/org/tests/query/joins/TestQueryJoinQueryNonRoot.java
rename to ebean-test/src/test/java/org/tests/query/joins/TestQueryJoinQueryNonRoot.java
index b24c07472..7d417f1ed 100644
--- a/ebean-core/src/test/java/org/tests/query/joins/TestQueryJoinQueryNonRoot.java
+++ b/ebean-test/src/test/java/org/tests/query/joins/TestQueryJoinQueryNonRoot.java
@@ -1,40 +1,41 @@
 package org.tests.query.joins;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.el.ElPropertyValue;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestQueryJoinQueryNonRoot extends BaseTestCase {
 
   @Test
   public void test() {
 
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
-    BeanDescriptor<Order> d = server.getBeanDescriptor(Order.class);
-    ElPropertyValue elGetValue = d.getElGetValue("customer.contacts");
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
+    BeanDescriptor<Order> d = server.descriptor(Order.class);
+    ElPropertyValue elGetValue = d.elGetValue("customer.contacts");
 
-    Assert.assertTrue(elGetValue.containsMany());
+    assertTrue(elGetValue.containsMany());
 
     ResetBasicData.reset();
 
-    List<Order> list = Ebean.find(Order.class)
+    List<Order> list = DB.find(Order.class)
       .fetch("customer")
       .fetchQuery("customer.contacts", "firstName")
       .fetch("customer.contacts.group")
       .where().lt("id", 3).findList();
 
-    Assert.assertNotNull(list);
-    Assert.assertTrue(!list.isEmpty());
+    assertNotNull(list);
+    assertTrue(!list.isEmpty());
 
     for (Order order : list) {
       List<Contact> contacts = order.getCustomer().getContacts();
@@ -45,11 +46,11 @@ public class TestQueryJoinQueryNonRoot extends BaseTestCase {
 
     // String oq =
     // "find order join customer join customer.contacts join details (+query(4),+lazy(5))";
-    // Query<Order> q = Ebean.createQuery(Order.class, oq);
+    // Query<Order> q = DB.createQuery(Order.class, oq);
     // q.setAutoTune(false);
     // List<Order> list2 = q.findList();
     //
-    // Assert.assertTrue(list2.size() > 0);
+    // assertTrue(list2.size() > 0);
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/query/joins/TestQueryManyToOneWhereClauseJoin.java b/ebean-test/src/test/java/org/tests/query/joins/TestQueryManyToOneWhereClauseJoin.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/query/joins/TestQueryManyToOneWhereClauseJoin.java
rename to ebean-test/src/test/java/org/tests/query/joins/TestQueryManyToOneWhereClauseJoin.java
index e7a07bb2d..76e5952d0 100644
--- a/ebean-core/src/test/java/org/tests/query/joins/TestQueryManyToOneWhereClauseJoin.java
+++ b/ebean-test/src/test/java/org/tests/query/joins/TestQueryManyToOneWhereClauseJoin.java
@@ -1,12 +1,13 @@
 package org.tests.query.joins;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestQueryManyToOneWhereClauseJoin extends BaseTestCase {
 
@@ -19,7 +20,7 @@ public class TestQueryManyToOneWhereClauseJoin extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .where().ilike("customer.name", "rob%")
       .query();
 
@@ -27,7 +28,7 @@ public class TestQueryManyToOneWhereClauseJoin extends BaseTestCase {
 
     //select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, t0.kcustomer_id c7
     String expectedSql = "from o_order t0 join o_customer t1 on t1.id = t0.kcustomer_id where lower(t1.name) like ";
-    Assert.assertTrue(query.getGeneratedSql().contains(expectedSql));
+    assertTrue(query.getGeneratedSql().contains(expectedSql));
 
     // select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, t0.kcustomer_id c7
     // from o_order t0
@@ -43,7 +44,7 @@ public class TestQueryManyToOneWhereClauseJoin extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .where().disjunction().ilike("customer.name", "rob%").gt("id", 1).endJunction()
       .query();
 
@@ -51,7 +52,7 @@ public class TestQueryManyToOneWhereClauseJoin extends BaseTestCase {
 
     //select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, t0.kcustomer_id c7
     String expectedSql = "from o_order t0 join o_customer t1 on t1.id = t0.kcustomer_id where (lower(t1.name) like ";
-    Assert.assertTrue(query.getGeneratedSql().contains(expectedSql));
+    assertTrue(query.getGeneratedSql().contains(expectedSql));
 
     // select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, t0.kcustomer_id c7
     // from o_order t0
@@ -69,7 +70,7 @@ public class TestQueryManyToOneWhereClauseJoin extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .fetch("customer")
       .fetch("customer.contacts")
       .where().ilike("customer.name", "rob%")
@@ -78,9 +79,9 @@ public class TestQueryManyToOneWhereClauseJoin extends BaseTestCase {
     query.findList();
 
     String generatedSql = query.getGeneratedSql();
-    Assert.assertTrue(generatedSql.contains("from o_order t0 join o_customer t1 on t1.id = t0.kcustomer_id"));
-    Assert.assertTrue(generatedSql.contains("left join contact t2 on t2.customer_id = t1.id"));
-    Assert.assertTrue(generatedSql.contains("where lower(t1.name) like "));
+    assertTrue(generatedSql.contains("from o_order t0 join o_customer t1 on t1.id = t0.kcustomer_id"));
+    assertTrue(generatedSql.contains("left join contact t2 on t2.customer_id = t1.id"));
+    assertTrue(generatedSql.contains("where lower(t1.name) like "));
 
     // select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6,
     //        t1.id c7, t1.status c8, t1.name c9, t1.smallnote c10, t1.anniversary c11, t1.cretime c12, t1.updtime c13, t1.billing_address_id c14, t1.shipping_address_id c15,
diff --git a/ebean-core/src/test/java/org/tests/query/lazy/TestQueryDefaultBatchSize.java b/ebean-test/src/test/java/org/tests/query/lazy/TestQueryDefaultBatchSize.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/query/lazy/TestQueryDefaultBatchSize.java
rename to ebean-test/src/test/java/org/tests/query/lazy/TestQueryDefaultBatchSize.java
index e1d9afd02..ade9da0e7 100644
--- a/ebean-core/src/test/java/org/tests/query/lazy/TestQueryDefaultBatchSize.java
+++ b/ebean-test/src/test/java/org/tests/query/lazy/TestQueryDefaultBatchSize.java
@@ -1,14 +1,10 @@
 package org.tests.query.lazy;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.ProfileLocation;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.OrderDetail;
-import org.tests.model.basic.Product;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 
@@ -24,7 +20,7 @@ public class TestQueryDefaultBatchSize extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .setProfileLocation(loc0)
       .setLazyLoadBatchSize(2)
       .findEach(bean -> doStuff(bean));
@@ -35,7 +31,7 @@ public class TestQueryDefaultBatchSize extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Ebean.find(Order.class)
+    DB.find(Order.class)
       .setProfileLocation(loc1)
       .fetch("details", "id")
       .fetch("details.product", "sku")
@@ -51,7 +47,7 @@ public class TestQueryDefaultBatchSize extends BaseTestCase {
     ResetBasicData.reset();
 
     List<Order> orders =
-      Ebean.find(Order.class)
+      DB.find(Order.class)
         .setProfileLocation(loc2)
         .setLazyLoadBatchSize(2)
         .findList();
@@ -67,7 +63,7 @@ public class TestQueryDefaultBatchSize extends BaseTestCase {
     ResetBasicData.reset();
 
     List<Order> orders =
-      Ebean.find(Order.class)
+      DB.find(Order.class)
         .setProfileLocation(loc3)
         .fetch("details", "id")
         .fetch("details.product", "sku")
@@ -86,7 +82,7 @@ public class TestQueryDefaultBatchSize extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Order> orders = Ebean.find(Order.class)
+    List<Order> orders = DB.find(Order.class)
       .setLazyLoadBatchSize(100)
       .findList();
 
diff --git a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByClear.java b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByClear.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/query/orderby/TestOrderByClear.java
rename to ebean-test/src/test/java/org/tests/query/orderby/TestOrderByClear.java
index 371c4b128..6d09bf18c 100644
--- a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByClear.java
+++ b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByClear.java
@@ -1,15 +1,15 @@
 package org.tests.query.orderby;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.OrderBy;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestOrderByClear extends BaseTestCase {
 
@@ -18,7 +18,7 @@ public class TestOrderByClear extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .order().asc("orderDate");
 
 
@@ -26,7 +26,7 @@ public class TestOrderByClear extends BaseTestCase {
     assertTrue(orderBy.containsProperty("orderDate"));
 
     orderBy.clear();
-    Assert.assertFalse(orderBy.containsProperty("orderDate"));
+    assertFalse(orderBy.containsProperty("orderDate"));
 
     orderBy.asc("shipDate");
     assertTrue(orderBy.containsProperty("shipDate"));
diff --git a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByOnComplex.java b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByOnComplex.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/query/orderby/TestOrderByOnComplex.java
rename to ebean-test/src/test/java/org/tests/query/orderby/TestOrderByOnComplex.java
index 0e5ee65da..1c223c3ce 100644
--- a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByOnComplex.java
+++ b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByOnComplex.java
@@ -1,16 +1,16 @@
 package org.tests.query.orderby;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestOrderByOnComplex extends BaseTestCase {
 
@@ -19,13 +19,12 @@ public class TestOrderByOnComplex extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class).order().desc("customer");
+    Query<Order> query = DB.find(Order.class).order().desc("customer");
 
     query.findList();
 
     String sql = query.getGeneratedSql();
-    Assert.assertTrue(sql.contains("order by t0.kcustomer_id desc"));
-
+    assertTrue(sql.contains("order by t0.kcustomer_id desc"));
   }
 
   @Test
@@ -33,7 +32,7 @@ public class TestOrderByOnComplex extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .order("case when status=3 then 10 when status=2 then 11 else 99 end");
 
     List<Order> list = query.findList();
diff --git a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithDistinct.java b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithDistinct.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithDistinct.java
rename to ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithDistinct.java
index cf451eee2..9d7f1780b 100644
--- a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithDistinct.java
+++ b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithDistinct.java
@@ -1,23 +1,18 @@
 package org.tests.query.orderby;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-
-import org.junit.Assert;
-import org.junit.Test;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.MRole;
-import org.tests.model.basic.MUser;
-import org.tests.model.basic.MUserType;
-import org.tests.model.basic.ResetBasicData;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 import java.util.Set;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 
 public class TestOrderByWithDistinct extends BaseTestCase {
@@ -27,7 +22,7 @@ public class TestOrderByWithDistinct extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .where()
       .eq("junk", "blah")
       .eq("name", "jim")
@@ -44,9 +39,9 @@ public class TestOrderByWithDistinct extends BaseTestCase {
   @IgnorePlatform({Platform.MYSQL, Platform.MARIADB, Platform.SQLSERVER, Platform.NUODB}) // do not support nulls first/last
   public void testDistinctOn() {
 
-    MRole role = Ebean.getReference(MRole.class, 1);
+    MRole role = DB.reference(MRole.class, 1);
 
-    Query<MUser> query = Ebean.find(MUser.class)
+    Query<MUser> query = DB.find(MUser.class)
       .where()
       .eq("roles", role)
       .order("userName asc nulls first").query();
@@ -65,7 +60,7 @@ public class TestOrderByWithDistinct extends BaseTestCase {
 
   @Test
   public void testOrderByWithDistinct() {
-    Query<MUser> query = Ebean.find(MUser.class);
+    Query<MUser> query = DB.find(MUser.class);
     query.findList();
 
     assertSql(query).doesNotContain("order by");
@@ -76,7 +71,7 @@ public class TestOrderByWithDistinct extends BaseTestCase {
     if (isH2()) {
       assertSql(query).contains("from muser t0 limit 1000");
     }
-    query = Ebean.find(MUser.class)
+    query = DB.find(MUser.class)
         .where()
         .eq("roles.roleName", "A")
         .query();
@@ -102,25 +97,25 @@ public class TestOrderByWithDistinct extends BaseTestCase {
 		 */
 
     MUserType ut = new MUserType("md");
-    Ebean.save(ut);
+    DB.save(ut);
     MUser user1 = new MUser("one");
     user1.setUserType(ut);
-    Ebean.save(user1);
+    DB.save(user1);
     MUser user2 = new MUser("two");
     user2.setUserType(ut);
-    Ebean.save(user2);
+    DB.save(user2);
 
     MRole roleA = new MRole("A");
-    Ebean.save(roleA);
+    DB.save(roleA);
     MRole roleB = new MRole("B");
-    Ebean.save(roleB);
+    DB.save(roleB);
 
     user1.addRole(roleA);
-    Ebean.save(user1);
+    DB.save(user1);
     user2.addRole(roleB);
-    Ebean.save(user2);
+    DB.save(user2);
 
-    Query<MUser> query = Ebean.find(MUser.class)
+    Query<MUser> query = DB.find(MUser.class)
       .fetch("userType", "name")
       .where()
       .eq("roles.roleName", "A")
@@ -135,8 +130,8 @@ public class TestOrderByWithDistinct extends BaseTestCase {
     // where u1.role_name = ?
     // order by t1.name, t0.user_name; --bind(A)
 
-    Assert.assertEquals(1, list.size());
-    Assert.assertEquals(user1, list.get(0));
+    assertEquals(1, list.size());
+    assertEquals(user1, list.get(0));
     String generatedSql = query.getGeneratedSql();
     if (isPostgres()) {
       assertThat(generatedSql).contains("select distinct on (t1.name, t0.user_name, t0.userid) t0.userid"); // using distinct
@@ -152,7 +147,7 @@ public class TestOrderByWithDistinct extends BaseTestCase {
     // this problem also manifests when autofetch eliminates properties from the select that aren't used in the objects
     // still need them to be present for purpose of order by
     // so here I'm "simulating" a scenario where autofetch has dropped userType.name
-    query = Ebean.find(MUser.class)
+    query = DB.find(MUser.class)
       .setAutoTune(false)
       .select("userName")
       .fetch("userType", "name")
@@ -161,8 +156,8 @@ public class TestOrderByWithDistinct extends BaseTestCase {
       .order("userType.name").query();
     list = query.findList();
 
-    Assert.assertEquals(1, list.size());
-    Assert.assertEquals(user1, list.get(0));
+    assertEquals(1, list.size());
+    assertEquals(user1, list.get(0));
 
     // select distinct t0.userid c0, t0.user_name c1, t1.id c2, t1.name c3
     // from muser t0
diff --git a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithDistinctTake2.java b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithDistinctTake2.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithDistinctTake2.java
rename to ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithDistinctTake2.java
index 196001bab..f97b20167 100644
--- a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithDistinctTake2.java
+++ b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithDistinctTake2.java
@@ -1,30 +1,28 @@
 package org.tests.query.orderby;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
-import org.junit.Assert;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestOrderByWithDistinctTake2 extends BaseTestCase {
 
   @Test
   public void testRegex() {
-
     String test = "helloasc asc ASC desc DESC boodesc desc ASC";
 
     test = test.replaceAll("(?i)\\b asc\\b|\\b desc\\b", "");
-    Assert.assertEquals("helloasc boodesc", test);
+    assertEquals("helloasc boodesc", test);
   }
 
-
   @Test
   public void test() {
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id, name")
       .where().ilike("contacts.firstName", "R%")
       .order("name desc").query();
@@ -52,7 +50,7 @@ public class TestOrderByWithDistinctTake2 extends BaseTestCase {
   @Test
   public void testWithAscAndDesc() {
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id")
       .where().ilike("contacts.firstName", "R%")
       .order("name asc,id desc").query();
diff --git a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithFunction.java b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithFunction.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithFunction.java
rename to ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithFunction.java
index 70972ec28..b85867d7f 100644
--- a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithFunction.java
+++ b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithFunction.java
@@ -1,12 +1,13 @@
 package org.tests.query.orderby;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestOrderByWithFunction extends BaseTestCase {
 
@@ -18,12 +19,12 @@ public class TestOrderByWithFunction extends BaseTestCase {
     if (isSqlServer()) {
       length = "len";
     }
-    
-    Query<Customer> query = Ebean.find(Customer.class).order(length + "(name),name");
+
+    Query<Customer> query = DB.find(Customer.class).order(length + "(name),name");
 
     query.findList();
     String sql = query.getGeneratedSql();
 
-    Assert.assertTrue(sql.contains("order by " + length + "(t0.name)"));
+    assertTrue(sql.contains("order by " + length + "(t0.name)"));
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithMany.java b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithMany.java
similarity index 56%
rename from ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithMany.java
rename to ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithMany.java
index 7855fefcb..9a399d344 100644
--- a/ebean-core/src/test/java/org/tests/query/orderby/TestOrderByWithMany.java
+++ b/ebean-test/src/test/java/org/tests/query/orderby/TestOrderByWithMany.java
@@ -1,17 +1,18 @@
 package org.tests.query.orderby;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.ResetBasicData;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestOrderByWithMany extends BaseTestCase {
 
   @Test
@@ -32,9 +33,9 @@ public class TestOrderByWithMany extends BaseTestCase {
 
   private void checkWithLazyLoadingOnBuiltInMany() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Query<Order> query = Ebean.find(Order.class);
+    Query<Order> query = DB.find(Order.class);
 
     // a query that ensures we are going to lazy load on the details
     List<Order> orders = query.findList();
@@ -46,54 +47,54 @@ public class TestOrderByWithMany extends BaseTestCase {
     }
 
     // first one is the main query and others are lazy loading queries
-    List<String> loggedSql = LoggedSqlCollector.stop();
-    Assert.assertTrue(loggedSql.size() > 1);
+    List<String> loggedSql = LoggedSql.stop();
+    assertTrue(loggedSql.size() > 1);
 
     String lazyLoadSql = loggedSql.get(1);
     // contains the foreign key back to the parent bean (t0.order_id)
-    Assert.assertTrue(lazyLoadSql, trimSql(lazyLoadSql, 2).contains("select t0.order_id, t0.id"));
-    Assert.assertTrue(lazyLoadSql.contains("order by t0.order_id, t0.id, t0.order_qty, t0.cretime desc"));
+    assertTrue(trimSql(lazyLoadSql, 2).contains("select t0.order_id, t0.id"));
+    assertTrue(lazyLoadSql.contains("order by t0.order_id, t0.id, t0.order_qty, t0.cretime desc"));
 
   }
 
   private void checkWithBuiltInManyBasic() {
 
-    Query<Order> query = Ebean.find(Order.class).fetch("details");
+    Query<Order> query = DB.find(Order.class).fetch("details");
     query.findList();
 
     String sql = query.getGeneratedSql();
 
-    Assert.assertTrue(sql.contains("order by t0.id, t1.id asc, t1.order_qty asc, t1.cretime desc"));
+    assertTrue(sql.contains("order by t0.id, t1.id asc, t1.order_qty asc, t1.cretime desc"));
   }
 
   private void checkWithBuiltInMany() {
 
-    Query<Order> query = Ebean.find(Order.class).fetch("details").order().desc("customer.name");
+    Query<Order> query = DB.find(Order.class).fetch("details").order().desc("customer.name");
 
     query.findList();
 
     String sql = query.getGeneratedSql();
 
     // t0.id inserted into the middle of the order by
-    Assert.assertTrue(sql.contains("order by t1.name desc, t0.id, t2.id asc"));
-    Assert.assertTrue(sql.contains("t2.id asc, t2.order_qty asc, t2.cretime desc"));
+    assertTrue(sql.contains("order by t1.name desc, t0.id, t2.id asc"));
+    assertTrue(sql.contains("t2.id asc, t2.order_qty asc, t2.cretime desc"));
   }
 
   private void checkAppendId() {
 
-    Query<Order> query = Ebean.find(Order.class).fetch("shipments").order().desc("customer.name");
+    Query<Order> query = DB.find(Order.class).fetch("shipments").order().desc("customer.name");
 
     query.findList();
 
     String sql = query.getGeneratedSql();
 
     // append the id to ensure ordering of root level objects
-    Assert.assertTrue(sql.contains("order by t1.name desc, t0.id"));
+    assertTrue(sql.contains("order by t1.name desc, t0.id"));
   }
 
   private void checkNone() {
 
-    Query<Order> query = Ebean.find(Order.class).order().desc("customer.name");
+    Query<Order> query = DB.find(Order.class).order().desc("customer.name");
 
     query.findList();
 
@@ -101,55 +102,55 @@ public class TestOrderByWithMany extends BaseTestCase {
 
     // no need to append id to order by as there is no 'many' included in the
     // query
-    Assert.assertTrue(sql.contains("order by t1.name desc"));
-    Assert.assertTrue(!sql.contains("order by t1.name desc,"));
+    assertTrue(sql.contains("order by t1.name desc"));
+    assertTrue(!sql.contains("order by t1.name desc,"));
   }
 
   private void checkBoth() {
 
-    Query<Order> query = Ebean.find(Order.class).fetch("shipments").order()
+    Query<Order> query = DB.find(Order.class).fetch("shipments").order()
       .desc("customer.name, shipments.shipTime");
 
     query.findList();
 
     String sql = query.getGeneratedSql();
     // insert id into the middle of the order by
-    Assert.assertTrue(sql.contains("order by t1.name, t0.id, t2.ship_time desc"));
+    assertTrue(sql.contains("order by t1.name, t0.id, t2.ship_time desc"));
   }
 
   private void checkPrepend() {
 
-    Query<Order> query = Ebean.find(Order.class).fetch("shipments").order()
+    Query<Order> query = DB.find(Order.class).fetch("shipments").order()
       .desc("shipments.shipTime");
 
     query.findList();
 
     String sql = query.getGeneratedSql();
     // prepend id in order by
-    Assert.assertTrue(sql.contains("order by t0.id, t1.ship_time desc"));
+    assertTrue(sql.contains("order by t0.id, t1.ship_time desc"));
   }
 
   private void checkAlreadyIncluded() {
 
-    Query<Order> query = Ebean.find(Order.class).fetch("shipments").order()
+    Query<Order> query = DB.find(Order.class).fetch("shipments").order()
       .desc("id, shipments.shipTime");
 
     query.findList();
 
     String sql = query.getGeneratedSql();
     // prepend id in order by
-    Assert.assertTrue(sql.contains("order by t0.id, t1.ship_time desc"));
+    assertTrue(sql.contains("order by t0.id, t1.ship_time desc"));
   }
 
   private void checkAlreadyIncluded2() {
 
-    Query<Order> query = Ebean.find(Order.class).fetch("shipments").order()
+    Query<Order> query = DB.find(Order.class).fetch("shipments").order()
       .desc("orderDate, id, shipments.shipTime");
 
     query.findList();
 
     String sql = query.getGeneratedSql();
     // prepend id in order by
-    Assert.assertTrue(sql.contains("order by t0.order_date, t0.id, t1.ship_time desc"));
+    assertTrue(sql.contains("order by t0.order_date, t0.id, t1.ship_time desc"));
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestFetchPreference.java b/ebean-test/src/test/java/org/tests/query/other/TestFetchPreference.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/query/other/TestFetchPreference.java
rename to ebean-test/src/test/java/org/tests/query/other/TestFetchPreference.java
index 806d2200f..37a09cb7a 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestFetchPreference.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestFetchPreference.java
@@ -1,9 +1,9 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.converstation.Conversation;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -13,7 +13,7 @@ public class TestFetchPreference extends BaseTestCase {
   @Test
   public void fetchPreference_overrideOrder() {
 
-    Query<Conversation> query = Ebean.find(Conversation.class)
+    Query<Conversation> query = DB.find(Conversation.class)
       // FetchPreference overrides so participants is joined and messages query joined
       .fetch("messages")
       .fetch("participants");
@@ -27,7 +27,7 @@ public class TestFetchPreference extends BaseTestCase {
   @Test
   public void fetchPreference_sr() {
 
-    Query<Conversation> query = Ebean.find(Conversation.class)
+    Query<Conversation> query = DB.find(Conversation.class)
       // without FetchPreference this ToMany would be our first ToMany join
       // and participants would be query joined
       .fetch("group.users")
@@ -44,7 +44,7 @@ public class TestFetchPreference extends BaseTestCase {
   @Test
   public void fetchPreference_inOrder() {
 
-    Query<Conversation> query = Ebean.find(Conversation.class)
+    Query<Conversation> query = DB.find(Conversation.class)
       .fetch("participants")
       .fetch("messages");
 
@@ -56,7 +56,7 @@ public class TestFetchPreference extends BaseTestCase {
   @Test
   public void fetchQuery_onlyOneJoinCandidate() {
 
-    Query<Conversation> query = Ebean.find(Conversation.class)
+    Query<Conversation> query = DB.find(Conversation.class)
       .fetch("messages")
       .fetchQuery("participants");
 
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestFindIdsWithInheritance.java b/ebean-test/src/test/java/org/tests/query/other/TestFindIdsWithInheritance.java
similarity index 58%
rename from ebean-core/src/test/java/org/tests/query/other/TestFindIdsWithInheritance.java
rename to ebean-test/src/test/java/org/tests/query/other/TestFindIdsWithInheritance.java
index 35f430b5b..9ca47f36c 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestFindIdsWithInheritance.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestFindIdsWithInheritance.java
@@ -1,14 +1,15 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Truck;
 import org.tests.model.basic.Vehicle;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestFindIdsWithInheritance extends BaseTestCase {
 
   @Test
@@ -17,13 +18,12 @@ public class TestFindIdsWithInheritance extends BaseTestCase {
     Truck truck = new Truck();
     truck.setLicenseNumber("TK123");
 
-    Ebean.save(truck);
+    DB.save(truck);
 
-    List<Integer> ids = Ebean.find(Vehicle.class).findIds();
-    Assert.assertNotNull(ids);
-
-    Ebean.delete(truck);
+    List<Integer> ids = DB.find(Vehicle.class).findIds();
+    assertNotNull(ids);
 
+    DB.delete(truck);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestFindIterateHeapDump.java b/ebean-test/src/test/java/org/tests/query/other/TestFindIterateHeapDump.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/query/other/TestFindIterateHeapDump.java
rename to ebean-test/src/test/java/org/tests/query/other/TestFindIterateHeapDump.java
index 3c395f3d6..cc2a58594 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestFindIterateHeapDump.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestFindIterateHeapDump.java
@@ -1,12 +1,12 @@
 package org.tests.query.other;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import org.tests.model.basic.EBasic;
 import com.sun.management.HotSpotDiagnosticMXBean;
-import org.junit.Ignore;
-import org.junit.Test;
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.EBasic;
 
 import javax.management.MBeanServer;
 import java.io.File;
@@ -28,11 +28,11 @@ public class TestFindIterateHeapDump extends BaseTestCase {
   /**
    * Ignore this test generally - run it manually against MySQL specifically for Issue #56.
    */
-  @Ignore
+  @Disabled
   @Test
   public void test() {
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
 
 //    Transaction transaction = server.beginTransaction();
 //    try {
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestFindPartialWithConstructorSetFields.java b/ebean-test/src/test/java/org/tests/query/other/TestFindPartialWithConstructorSetFields.java
similarity index 64%
rename from ebean-core/src/test/java/org/tests/query/other/TestFindPartialWithConstructorSetFields.java
rename to ebean-test/src/test/java/org/tests/query/other/TestFindPartialWithConstructorSetFields.java
index ff9dcb89f..7ea317f94 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestFindPartialWithConstructorSetFields.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestFindPartialWithConstructorSetFields.java
@@ -2,16 +2,15 @@ package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 import java.util.Set;
 
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestFindPartialWithConstructorSetFields extends BaseTestCase {
 
@@ -20,7 +19,7 @@ public class TestFindPartialWithConstructorSetFields extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Order> list = Ebean.find(Order.class)
+    List<Order> list = DB.find(Order.class)
       .setLazyLoadBatchSize(100)
       .setUseCache(false)
       .select("shipDate")
@@ -30,11 +29,11 @@ public class TestFindPartialWithConstructorSetFields extends BaseTestCase {
 
     // assert first bean is partially loaded
     Order order0 = list.get(0);
-    BeanState beanState = Ebean.getBeanState(order0);
-    Set<String> loadedProps = beanState.getLoadedProps();
+    BeanState beanState = DB.beanState(order0);
+    Set<String> loadedProps = beanState.loadedProps();
     assertTrue(loadedProps.contains("shipDate"));
-    assertTrue(!loadedProps.contains("status"));
-    assertTrue(!loadedProps.contains("orderDate"));
+    assertFalse(loadedProps.contains("status"));
+    assertFalse(loadedProps.contains("orderDate"));
 
     // invoke lazy loading
     order0.getStatus();
@@ -43,8 +42,8 @@ public class TestFindPartialWithConstructorSetFields extends BaseTestCase {
     // assert that these beans are fully loaded
     for (int i = 1; i < list.size(); i++) {
       Order order1 = list.get(1);
-      beanState = Ebean.getBeanState(order1);
-      loadedProps = beanState.getLoadedProps();
+      beanState = DB.beanState(order1);
+      loadedProps = beanState.loadedProps();
       assertNull(loadedProps);
     }
 
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestFindWhereUsingEnumerated.java b/ebean-test/src/test/java/org/tests/query/other/TestFindWhereUsingEnumerated.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/query/other/TestFindWhereUsingEnumerated.java
rename to ebean-test/src/test/java/org/tests/query/other/TestFindWhereUsingEnumerated.java
index 274b5eeb4..4680763cf 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestFindWhereUsingEnumerated.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestFindWhereUsingEnumerated.java
@@ -1,8 +1,8 @@
 package org.tests.query.other;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.TransactionalTestCase;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MNonEnum;
 import org.tests.model.basic.MNonUpdPropEntity;
 
@@ -18,9 +18,9 @@ public class TestFindWhereUsingEnumerated extends TransactionalTestCase {
     e.setName("TheNonEnumIsEnd");
     e.setNote("note");
 
-    Ebean.save(e);
+    DB.save(e);
 
-    MNonUpdPropEntity unique = Ebean.find(MNonUpdPropEntity.class).where()
+    MNonUpdPropEntity unique = DB.find(MNonUpdPropEntity.class).where()
       .eq("nonEnum", MNonEnum.END)
       .eq("name", "TheNonEnumIsEnd")
       .findOne();
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestFormulaWithFindCount.java b/ebean-test/src/test/java/org/tests/query/other/TestFormulaWithFindCount.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/query/other/TestFormulaWithFindCount.java
rename to ebean-test/src/test/java/org/tests/query/other/TestFormulaWithFindCount.java
index b4d50582c..1109e3043 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestFormulaWithFindCount.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestFormulaWithFindCount.java
@@ -1,16 +1,18 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.ExpressionList;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestFormulaWithFindCount extends BaseTestCase {
 
   @Test
@@ -18,7 +20,7 @@ public class TestFormulaWithFindCount extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
 
     ExpressionList<Order> ex = server.find(Order.class).select("id, status ,totalAmount").where().gt("totalAmount", 1d);
@@ -26,12 +28,12 @@ public class TestFormulaWithFindCount extends BaseTestCase {
 
     for (Order order : list) {
       Double amount = order.getTotalAmount();
-      Assert.assertNotNull(amount);
+      assertNotNull(amount);
     }
 
     ExpressionList<Order> expressionList = server.find(Order.class).where().gt("totalAmount", 1d);
     int rowCount = expressionList.findCount();
-    Assert.assertEquals(list.size(), rowCount);
+    assertEquals(list.size(), rowCount);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestLikeEscaping.java b/ebean-test/src/test/java/org/tests/query/other/TestLikeEscaping.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/query/other/TestLikeEscaping.java
rename to ebean-test/src/test/java/org/tests/query/other/TestLikeEscaping.java
index d5eb0e92c..b52522de9 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestLikeEscaping.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestLikeEscaping.java
@@ -2,10 +2,9 @@ package org.tests.query.other;
 
 import io.ebean.DB;
 import io.ebean.TransactionalTestCase;
-
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestManyLazyLoadingQuery.java b/ebean-test/src/test/java/org/tests/query/other/TestManyLazyLoadingQuery.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/query/other/TestManyLazyLoadingQuery.java
rename to ebean-test/src/test/java/org/tests/query/other/TestManyLazyLoadingQuery.java
index 4070496c1..c0f3deff8 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestManyLazyLoadingQuery.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestManyLazyLoadingQuery.java
@@ -1,15 +1,15 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.SpiQuery;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -23,17 +23,17 @@ public class TestManyLazyLoadingQuery extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
 
-    BeanDescriptor<Order> descOrder = server.getBeanDescriptor(Order.class);
-    BeanPropertyAssocMany<?> beanProperty = (BeanPropertyAssocMany<?>) descOrder.getBeanProperty("details");
+    BeanDescriptor<Order> descOrder = server.descriptor(Order.class);
+    BeanPropertyAssocMany<?> beanProperty = (BeanPropertyAssocMany<?>) descOrder.beanProperty("details");
 
     List<Object> parentIds = new ArrayList<>();
     parentIds.add(1);
 
 
     List<Order> orders =
-      Ebean.find(Order.class)
+      DB.find(Order.class)
         .where().lt("id", 4)
         .findList();
 
@@ -44,11 +44,11 @@ public class TestManyLazyLoadingQuery extends BaseTestCase {
 
 
     // start transaction to keep PC going to lazy query
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
-      Ebean.find(Order.class, 1);
+      DB.find(Order.class, 1);
 
-      SpiQuery<?> query0 = (SpiQuery<?>) Ebean.find(OrderDetail.class);
+      SpiQuery<?> query0 = (SpiQuery<?>) DB.find(OrderDetail.class);
 
       query0.setLazyLoadForParents(beanProperty);
 
@@ -59,10 +59,10 @@ public class TestManyLazyLoadingQuery extends BaseTestCase {
       platformAssertIn(query0.getGeneratedSql(), "where (t0.order_id)");
 
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
 
-    List<OrderDetail> details = Ebean.find(OrderDetail.class)
+    List<OrderDetail> details = DB.find(OrderDetail.class)
       .where().eq("order.id", 1)
       .findList();
 
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestManyToManyLazyLoading.java b/ebean-test/src/test/java/org/tests/query/other/TestManyToManyLazyLoading.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/query/other/TestManyToManyLazyLoading.java
rename to ebean-test/src/test/java/org/tests/query/other/TestManyToManyLazyLoading.java
index a3e331311..052165d16 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestManyToManyLazyLoading.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestManyToManyLazyLoading.java
@@ -1,10 +1,10 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.MRole;
 import org.tests.model.basic.MUser;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -15,7 +15,7 @@ public class TestManyToManyLazyLoading extends BaseTestCase {
 
     createData();
 
-    List<MUser> users = Ebean.find(MUser.class).findList();
+    List<MUser> users = DB.find(MUser.class).findList();
 
     for (MUser user : users) {
       List<MRole> roles = user.getRoles();
@@ -28,14 +28,14 @@ public class TestManyToManyLazyLoading extends BaseTestCase {
     MRole r0 = new MRole("r0");
     MRole r1 = new MRole("r1");
 
-    Ebean.save(r0);
-    Ebean.save(r1);
+    DB.save(r0);
+    DB.save(r1);
 
     MUser u0 = new MUser("usr0");
     u0.addRole(r0);
     u0.addRole(r1);
 
-    Ebean.save(u0);
+    DB.save(u0);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestOneToManyAsMap.java b/ebean-test/src/test/java/org/tests/query/other/TestOneToManyAsMap.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/query/other/TestOneToManyAsMap.java
rename to ebean-test/src/test/java/org/tests/query/other/TestOneToManyAsMap.java
index 36da8bd82..71b49dc82 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestOneToManyAsMap.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestOneToManyAsMap.java
@@ -2,7 +2,7 @@ package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.map.MpRole;
 import org.tests.model.map.MpUser;
 
@@ -10,8 +10,8 @@ import java.util.LinkedHashMap;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestOneToManyAsMap extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestQueryConversationRowCount.java b/ebean-test/src/test/java/org/tests/query/other/TestQueryConversationRowCount.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/query/other/TestQueryConversationRowCount.java
rename to ebean-test/src/test/java/org/tests/query/other/TestQueryConversationRowCount.java
index db528a536..9ea1847a1 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestQueryConversationRowCount.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestQueryConversationRowCount.java
@@ -1,16 +1,16 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.converstation.Conversation;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestQueryConversationRowCount extends BaseTestCase {
 
@@ -23,7 +23,7 @@ public class TestQueryConversationRowCount extends BaseTestCase {
     Long groupId = 1L;
     Long userId = 1L;
 
-    Query<Conversation> query = Ebean.find(Conversation.class)
+    Query<Conversation> query = DB.find(Conversation.class)
       .where().eq("group.id", groupId)
       .disjunction()
       .conjunction()
@@ -52,7 +52,7 @@ public class TestQueryConversationRowCount extends BaseTestCase {
     assertThat(generatedSql).contains("where t0.group_id = ? and ((t0.isopen = ? and u1.user_id = ?) or t0.isopen = ?)");
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.findCount();
 
     // select count(*) from (
@@ -62,8 +62,8 @@ public class TestQueryConversationRowCount extends BaseTestCase {
     //   where t0.group_id = ?  and ((t0.open = ?  and u1.user_id = ? )  or t0.open = ? )
     // ); --bind(1,true,1,true)
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
-    Assert.assertEquals(1, loggedSql.size());
+    List<String> loggedSql = LoggedSql.stop();
+    assertEquals(1, loggedSql.size());
 
     String countSql = trimSql(loggedSql.get(0), 0);
     assertThat(countSql).contains("select count(*) from ( select distinct t0.id from c_conversation t0 left join c_participation u1 on u1.conversation_id = t0.id where t0.group_id = ? and ((t0.isopen = ? and u1.user_id = ?) or t0.isopen = ?))");
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestQueryDistinct.java b/ebean-test/src/test/java/org/tests/query/other/TestQueryDistinct.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/query/other/TestQueryDistinct.java
rename to ebean-test/src/test/java/org/tests/query/other/TestQueryDistinct.java
index 3a16940b0..8f64e0836 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestQueryDistinct.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestQueryDistinct.java
@@ -1,20 +1,18 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
-import static junit.framework.TestCase.assertNull;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestQueryDistinct extends BaseTestCase {
 
@@ -23,7 +21,7 @@ public class TestQueryDistinct extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .setDistinct(true)
       .select("name");
 
@@ -49,7 +47,7 @@ public class TestQueryDistinct extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .where().setDistinct(true)
       .select("name");
 
@@ -64,7 +62,7 @@ public class TestQueryDistinct extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .setDistinct(true)
       .select("status")
       .where().isNotNull("status").query();
@@ -89,7 +87,7 @@ public class TestQueryDistinct extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .setMaxRows(10)
       .setDistinct(true)
       .select("name");
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestQueryRawExpressionMany.java b/ebean-test/src/test/java/org/tests/query/other/TestQueryRawExpressionMany.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/query/other/TestQueryRawExpressionMany.java
rename to ebean-test/src/test/java/org/tests/query/other/TestQueryRawExpressionMany.java
index 55901a720..153e3c120 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestQueryRawExpressionMany.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestQueryRawExpressionMany.java
@@ -1,12 +1,12 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -21,14 +21,14 @@ public class TestQueryRawExpressionMany extends BaseTestCase {
 
     Integer quantity = 1;
 
-    Query<Order> query = Ebean.find(Order.class)
+    Query<Order> query = DB.find(Order.class)
       .where().raw("details.orderQty = ?", quantity)
       .query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     query.findCount();
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(trimSql(sql.get(0), 1)).contains("select count(*) from ( select distinct t0.id from o_order t0 left join o_order_detail t1 on t1.order_id = t0.id and t1.id > 0 where t1.order_qty = ?)");
   }
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestQueryRowCountWithMany.java b/ebean-test/src/test/java/org/tests/query/other/TestQueryRowCountWithMany.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/query/other/TestQueryRowCountWithMany.java
rename to ebean-test/src/test/java/org/tests/query/other/TestQueryRowCountWithMany.java
index 44c8a78f0..54740de23 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestQueryRowCountWithMany.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestQueryRowCountWithMany.java
@@ -3,15 +3,15 @@ package org.tests.query.other;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestQueryRowCountWithMany extends BaseTestCase {
 
@@ -20,7 +20,7 @@ public class TestQueryRowCountWithMany extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Long productId = 1L;
 
@@ -64,7 +64,7 @@ public class TestQueryRowCountWithMany extends BaseTestCase {
     // u1.product_id = ?
     // ); --bind(1)
 
-    List<String> sqlLogged = LoggedSqlCollector.stop();
+    List<String> sqlLogged = LoggedSql.stop();
 
     assertEquals(list.size(), rowCount);
     assertEquals(2, sqlLogged.size());
@@ -89,10 +89,10 @@ public class TestQueryRowCountWithMany extends BaseTestCase {
       .orderBy("cretime asc")
       .query();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.findCount();
 
-    List<String> sqlLogged = LoggedSqlCollector.stop();
+    List<String> sqlLogged = LoggedSql.stop();
 
     assertEquals(1, sqlLogged.size());
     assertThat(trimSql(sqlLogged.get(0), 1)).contains("select count(*) from ( select distinct t0.id from o_order t0 join o_order_detail u1 on u1.order_id = t0.id and u1.id > 0 where u1.product_id = ?)");
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestQuerySingleAttribute.java b/ebean-test/src/test/java/org/tests/query/other/TestQuerySingleAttribute.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/query/other/TestQuerySingleAttribute.java
rename to ebean-test/src/test/java/org/tests/query/other/TestQuerySingleAttribute.java
index 989ae123d..735bddddd 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestQuerySingleAttribute.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestQuerySingleAttribute.java
@@ -1,25 +1,16 @@
 package org.tests.query.other;
 
-import io.ebean.BaseTestCase;
-import io.ebean.CountDistinctOrder;
-import io.ebean.CountedValue;
-import io.ebean.DB;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
+import io.ebean.*;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.tests.inherit.ChildA;
 import org.tests.inherit.Data;
 import org.tests.inherit.EUncle;
 import org.tests.lazyforeignkeys.MainEntity;
 import org.tests.lazyforeignkeys.MainEntityRelation;
-import org.tests.model.basic.Contact;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.ResetBasicData;
-import org.tests.model.basic.VwCustomer;
+import org.tests.model.basic.*;
 import org.tests.o2m.OmBasicParent;
 
 import java.sql.Date;
@@ -76,7 +67,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
     ResetBasicData.reset();
 
     List<String> names =
-      Ebean.find(Customer.class)
+      DB.find(Customer.class)
         .setDistinct(true)
         .select("name")
         .where().eq("status", Customer.Status.NEW).startsWith("name", "R")
@@ -96,7 +87,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
     ResetBasicData.reset();
 
     List<Date> dates =
-      Ebean.find(Customer.class)
+      DB.find(Customer.class)
         .setDistinct(true)
         .select("anniversary")
         .where().isNotNull("anniversary")
@@ -110,7 +101,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
   public void withOrderBy() {
 
     Query<Customer> query =
-      Ebean.find(Customer.class)
+      DB.find(Customer.class)
         .setDistinct(true)
         .select("name")
         .where().eq("status", Customer.Status.NEW)
@@ -125,7 +116,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class).select("name");
+    Query<Customer> query = DB.find(Customer.class).select("name");
 
     List<String> names = query.findSingleAttributeList();
 
@@ -138,7 +129,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("name")
       .where().eq("id", 1).query();
 
@@ -151,7 +142,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
   @Test
   public void findSingleAttributeList_with_join_column() {
     ResetBasicData.reset();
-    Query<MainEntityRelation> query = Ebean.find(MainEntityRelation.class)
+    Query<MainEntityRelation> query = DB.find(MainEntityRelation.class)
       .fetch("entity1", "attr1")
       .setDistinct(true)
       .setCountDistinct(CountDistinctOrder.COUNT_DESC_ATTR_ASC)
@@ -173,7 +164,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
   @Test
   public void findSingleAttributesVariousSelection1() {
-    Query<MainEntityRelation> query = Ebean.find(MainEntityRelation.class)
+    Query<MainEntityRelation> query = DB.find(MainEntityRelation.class)
       .fetch("entity1", "attr1")
       .setCountDistinct(CountDistinctOrder.COUNT_DESC_ATTR_ASC)
       .where().query();
@@ -186,7 +177,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
   @Test
   public void findSingleAttributesVariousSelection2() {
-    Query<MainEntityRelation> query = Ebean.find(MainEntityRelation.class)
+    Query<MainEntityRelation> query = DB.find(MainEntityRelation.class)
       .select("attr1")
       .setCountDistinct(CountDistinctOrder.COUNT_DESC_ATTR_ASC)
       .where().query();
@@ -199,7 +190,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
   @Test
   public void findSingleAttributesVariousSelection3() {
-    Query<MainEntityRelation> query = Ebean.find(MainEntityRelation.class)
+    Query<MainEntityRelation> query = DB.find(MainEntityRelation.class)
       .select("id")
       .setCountDistinct(CountDistinctOrder.COUNT_DESC_ATTR_ASC)
       .where().query();
@@ -212,7 +203,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
   @Test
   public void findSingleAttributesVariousSelection4() {
-    Query<MainEntityRelation> query = Ebean.find(MainEntityRelation.class)
+    Query<MainEntityRelation> query = DB.find(MainEntityRelation.class)
       .fetch("entity1", "id")
       .setCountDistinct(CountDistinctOrder.COUNT_DESC_ATTR_ASC)
       .where().query();
@@ -225,7 +216,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
   @Test
   public void findSingleAttributesVariousSelection5() {
-    Query<OmBasicParent> query = Ebean.find(OmBasicParent.class)
+    Query<OmBasicParent> query = DB.find(OmBasicParent.class)
       .fetch("children", "name")
       .setCountDistinct(CountDistinctOrder.COUNT_DESC_ATTR_ASC)
       .where().query();
@@ -240,7 +231,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("max(name)")
       .where().gt("id", 1).query();
 
@@ -255,7 +246,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    String name = Ebean.find(Customer.class)
+    String name = DB.find(Customer.class)
       .select("name")
       .where().eq("id", 1)
       .findSingleAttribute();
@@ -268,7 +259,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .setDistinct(true)
       .select("name")
       .where().eq("status", Customer.Status.NEW)
@@ -285,7 +276,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .setDistinct(true)
       .select("name")
       .where().eq("status", Customer.Status.NEW)
@@ -304,18 +295,18 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class).select("name");
+    Query<Customer> query = DB.find(Customer.class).select("name");
     query.findSingleAttributeList();
     assertThat(sqlOf(query)).contains("select t0.name from o_customer t0");
 
-    Query<Customer> query2 = Ebean.find(Customer.class).select("name");
+    Query<Customer> query2 = DB.find(Customer.class).select("name");
     query2.findList();
     assertThat(sqlOf(query2, 1)).contains("select t0.id, t0.name from o_customer t0");
   }
 
   @Test
   public void distinctOnIdProperty() {
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .setDistinct(true)
       .select("id")
       .setMaxRows(100);
@@ -336,7 +327,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .setDistinct(true)
       .fetch("billingAddress", "city");
 
@@ -351,7 +342,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .setDistinct(true)
       .fetch("customer.billingAddress", "city");
 
@@ -366,7 +357,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<ChildA> query = Ebean.find(ChildA.class)
+    Query<ChildA> query = DB.find(ChildA.class)
       .setDistinct(true)
       .select("more");
 
@@ -379,7 +370,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<EUncle> query = Ebean.find(EUncle.class)
+    Query<EUncle> query = DB.find(EUncle.class)
       .setDistinct(true)
       .fetch("parent", "more");
 
@@ -395,7 +386,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .select("id")
       .setMaxRows(100);
 
@@ -415,7 +406,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .fetch("billingAddress", "city");
 
     List<String> cities = query.findSingleAttributeList();
@@ -429,7 +420,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<VwCustomer> query = Ebean.find(VwCustomer.class)
+    Query<VwCustomer> query = DB.find(VwCustomer.class)
       .fetch("billingAddress", "city");
 
     List<String> cities = query.findSingleAttributeList();
@@ -443,7 +434,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<ChildA> query = Ebean.find(ChildA.class)
+    Query<ChildA> query = DB.find(ChildA.class)
       .select("more");
 
     query.findSingleAttributeList();
@@ -456,7 +447,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<EUncle> query = Ebean.find(EUncle.class)
+    Query<EUncle> query = DB.find(EUncle.class)
       .fetch("parent", "more");
 
     query.findSingleAttributeList();
@@ -469,7 +460,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<EUncle> query = Ebean.find(EUncle.class)
+    Query<EUncle> query = DB.find(EUncle.class)
       .fetch("parent", "more");
 
     query.findSingleAttributeList();
@@ -478,12 +469,12 @@ public class TestQuerySingleAttribute extends BaseTestCase {
   }
 
   @Test
-  @Ignore //don't know if ebean can handle this on many to many, as this means that the cartesian product is generated
+  @Disabled //don't know if ebean can handle this on many to many, as this means that the cartesian product is generated
   public void distinctFetchManyToManyInheritedBean() {
 
     ResetBasicData.reset();
 
-    Query<Data> query = Ebean.find(Data.class)
+    Query<Data> query = DB.find(Data.class)
       .setDistinct(true)
       .fetch("parents", "more")
       .setMaxRows(100);
@@ -500,7 +491,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .setDistinct(true)
       .select("customer")
       .order().desc("customer");
@@ -515,7 +506,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .setDistinct(true)
       .select("customer.id")
       .order().desc("customer.id");
@@ -530,7 +521,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .setDistinct(true)
       .fetch("customer", "billingAddress")
       .order().desc("customer.billingAddress");
@@ -545,7 +536,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .setDistinct(true)
       .fetch("customer", "billingAddress")
       .where().eq("customer.billingAddress.city", "Auckland")
@@ -566,7 +557,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .setDistinct(true)
       .fetch("customer", "billingAddress")
       .where().eq("customer.billingAddress.city", "Auckland")
@@ -587,7 +578,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .setDistinct(true)
       .fetch("customer", "billingAddress")
       .where().eq("customer.billingAddress.city", "Auckland")
@@ -608,7 +599,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .setDistinct(true)
       .fetch("customer", "billingAddress")
       .where().eq("customer.shippingAddress.city", "Auckland") // query on shippingAddress
@@ -631,10 +622,10 @@ public class TestQuerySingleAttribute extends BaseTestCase {
     ResetBasicData.reset();
 
 
-    int count = Ebean.find(Contact.class).findCount();
+    int count = DB.find(Contact.class).findCount();
     assertThat(count).isGreaterThanOrEqualTo(12);
 
-    Query<Contact> query = Ebean.find(Contact.class)
+    Query<Contact> query = DB.find(Contact.class)
       .select("firstName");
 
     List<CountedValue<Object>> list1 = query
@@ -649,21 +640,21 @@ public class TestQuerySingleAttribute extends BaseTestCase {
     //assertThat(list1.toString()).isEqualTo("[3: Bugs1, 1: Fiona, 3: Fred1, 1: Jack, 3: Jim1, 1: Tracy]");
 
 
-    query = Ebean.find(Contact.class).select("firstName");
+    query = DB.find(Contact.class).select("firstName");
     list1 = query
       .setCountDistinct(CountDistinctOrder.ATTR_DESC)
       .findSingleAttributeList();
     assertThat(list1.get(0)).isInstanceOf(CountedValue.class);
     //assertThat(list1.toString()).isEqualTo("[1: Tracy, 3: Jim1, 1: Jack, 3: Fred1, 1: Fiona, 3: Bugs1]");
 
-    query = Ebean.find(Contact.class).select("firstName");
+    query = DB.find(Contact.class).select("firstName");
     list1 = query
       .setCountDistinct(CountDistinctOrder.COUNT_ASC_ATTR_DESC)
       .findSingleAttributeList();
     assertThat(list1.get(0)).isInstanceOf(CountedValue.class);
     //assertThat(list1.toString()).isEqualTo("[1: Tracy, 1: Jack, 1: Fiona, 3: Jim1, 3: Fred1, 3: Bugs1]");
 
-    query = Ebean.find(Contact.class).fetch("customer.shippingAddress", "line1");//("firstName")
+    query = DB.find(Contact.class).fetch("customer.shippingAddress", "line1");//("firstName")
     List<CountedValue<Object>> list2 = query
       .setCountDistinct(CountDistinctOrder.ATTR_ASC)
       .findSingleAttributeList();
@@ -676,7 +667,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
     //assertThat(list2.toString()).isEqualTo("[1: null, 3: 1 Banana St, 5: 12 Apple St, 3: 15 Kumera Way]");
 
 
-    query = Ebean.find(Contact.class).select("firstName")
+    query = DB.find(Contact.class).select("firstName")
       .where().eq("customer.shippingAddress.line1", "12 Apple St").query();
     List<CountedValue<Object>> list3 = query
       .setCountDistinct(CountDistinctOrder.ATTR_ASC)
@@ -690,7 +681,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
     //assertThat(list3.toString()).isEqualTo("[1: Bugs1, 1: Fiona, 1: Fred1, 1: Jim1, 1: Tracy]");
 
 
-    query = Ebean.find(Contact.class).fetch("customer.billingAddress", "line1")
+    query = DB.find(Contact.class).fetch("customer.billingAddress", "line1")
       .where().or()
       .ne("customer.shippingAddress.line1", "12 Apple St")
       .isNull("customer.shippingAddress.line1")
@@ -710,7 +701,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
 
     // Test Limiter for MSSQL
-    query = Ebean.find(Contact.class).fetch("customer.billingAddress", "line1").setFirstRow(1).setMaxRows(2);
+    query = DB.find(Contact.class).fetch("customer.billingAddress", "line1").setFirstRow(1).setMaxRows(2);
     List<CountedValue<Object>> list5 = query
       .where().isNotNull("customer.billingAddress.line1").query()
       .setCountDistinct(CountDistinctOrder.ATTR_DESC)
@@ -746,7 +737,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
 
     List<CountedValue<Order.Status>> orderStatusCount =
 
-      Ebean.find(Order.class)
+      DB.find(Order.class)
         .select("status")
         .where()
         .gt("orderDate", LocalDate.now().minusMonths(3))
@@ -758,7 +749,7 @@ public class TestQuerySingleAttribute extends BaseTestCase {
     }
   }
 
-  @Before
+  @BeforeEach
   public void setup() {
     MainEntity e1 = new MainEntity();
     e1.setId("1");
@@ -791,9 +782,9 @@ public class TestQuerySingleAttribute extends BaseTestCase {
     DB.save(rel);
   }
 
-  @After
+  @AfterEach
   public void cleanup() {
-    Ebean.find(MainEntityRelation.class).delete();
-    Ebean.find(MainEntity.class).delete();
+    DB.find(MainEntityRelation.class).delete();
+    DB.find(MainEntity.class).delete();
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestSelfParent.java b/ebean-test/src/test/java/org/tests/query/other/TestSelfParent.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/query/other/TestSelfParent.java
rename to ebean-test/src/test/java/org/tests/query/other/TestSelfParent.java
index ce15e7895..483b85998 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestSelfParent.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestSelfParent.java
@@ -1,19 +1,20 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.selfref.SelfParent;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestSelfParent extends BaseTestCase {
 
   @Test
   public void test() {
 
-    if (Ebean.find(SelfParent.class).findCount() > 0) {
+    if (DB.find(SelfParent.class).findCount() > 0) {
       // only run once
       return;
     }
@@ -28,21 +29,20 @@ public class TestSelfParent extends BaseTestCase {
     SelfParent child21 = new SelfParent("child21", child2);
     SelfParent child22 = new SelfParent("child22", child2);
 
-    Ebean.save(root);
-    Ebean.save(child1);
-    Ebean.save(child11);
-    Ebean.save(child111);
-    Ebean.save(child12);
-    Ebean.save(child2);
-    Ebean.save(child21);
-    Ebean.save(child22);
+    DB.save(root);
+    DB.save(child1);
+    DB.save(child11);
+    DB.save(child111);
+    DB.save(child12);
+    DB.save(child2);
+    DB.save(child21);
+    DB.save(child22);
 
-    List<SelfParent> roots = Ebean.find(SelfParent.class).where().eq("parent", null).findList();
+    List<SelfParent> roots = DB.find(SelfParent.class).where().eq("parent", null).findList();
 
-    Assert.assertEquals(1, roots.size());
+    assertEquals(1, roots.size());
 
     printNode(roots.get(0));
-
   }
 
   public static void printNode(SelfParent o) {
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestSubQueryBinding.java b/ebean-test/src/test/java/org/tests/query/other/TestSubQueryBinding.java
similarity index 58%
rename from ebean-core/src/test/java/org/tests/query/other/TestSubQueryBinding.java
rename to ebean-test/src/test/java/org/tests/query/other/TestSubQueryBinding.java
index ba51c90b8..c3eb3a2bd 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestSubQueryBinding.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestSubQueryBinding.java
@@ -1,23 +1,19 @@
 package org.tests.query.other;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import io.ebean.Expression;
-import io.ebean.Query;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
-import org.junit.Test;
 
 public class TestSubQueryBinding extends BaseTestCase {
 
   @Test
   public void test() {
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     Query<Customer> someCustomerIds = server.find(Customer.class).select("id").where().lt("id", 5).query();
 
-    Expression someCustIdsExpression = server.getExpressionFactory().in("id", someCustomerIds);
+    Expression someCustIdsExpression = server.expressionFactory().in("id", someCustomerIds);
 
     Query<Customer> query = server.find(Customer.class).where().like("name", "Rob%").not(someCustIdsExpression).query();
 
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestWhereAnnotation.java b/ebean-test/src/test/java/org/tests/query/other/TestWhereAnnotation.java
similarity index 60%
rename from ebean-core/src/test/java/org/tests/query/other/TestWhereAnnotation.java
rename to ebean-test/src/test/java/org/tests/query/other/TestWhereAnnotation.java
index c3ad40ce6..0f52d3dac 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestWhereAnnotation.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestWhereAnnotation.java
@@ -1,10 +1,9 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
@@ -12,6 +11,8 @@ import org.tests.model.basic.ResetBasicData;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestWhereAnnotation extends BaseTestCase {
 
@@ -20,18 +21,18 @@ public class TestWhereAnnotation extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    Ebean.find(Customer.class)
+    DB.find(Customer.class)
       .fetch("orders")
       .findList();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
-    Assert.assertEquals(1, loggedSql.size());
+    assertEquals(1, loggedSql.size());
 
     String sql = loggedSql.get(0);
-    Assert.assertTrue(sql.contains("t1.order_date is not null"));
+    assertTrue(sql.contains("t1.order_date is not null"));
   }
 
   @Test
@@ -39,11 +40,11 @@ public class TestWhereAnnotation extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Ebean.getServerCacheManager().clearAll();
+    DB.cacheManager().clearAll();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    List<Customer> customers = Ebean.find(Customer.class)
+    List<Customer> customers = DB.find(Customer.class)
       .order().asc("id")
       .findList();
 
@@ -51,7 +52,7 @@ public class TestWhereAnnotation extends BaseTestCase {
     assertThat(orders.size()).isGreaterThan(0);
     orders.get(0).getStatus();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(2);
     assertThat(loggedSql.get(1)).contains("t0.order_date is not null");
diff --git a/ebean-core/src/test/java/org/tests/query/other/TestWhereLikeWithSlash.java b/ebean-test/src/test/java/org/tests/query/other/TestWhereLikeWithSlash.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/query/other/TestWhereLikeWithSlash.java
rename to ebean-test/src/test/java/org/tests/query/other/TestWhereLikeWithSlash.java
index c36cd28c8..e637d2411 100644
--- a/ebean-core/src/test/java/org/tests/query/other/TestWhereLikeWithSlash.java
+++ b/ebean-test/src/test/java/org/tests/query/other/TestWhereLikeWithSlash.java
@@ -1,14 +1,14 @@
 package org.tests.query.other;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
 
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestWhereLikeWithSlash extends BaseTestCase {
 
@@ -16,14 +16,14 @@ public class TestWhereLikeWithSlash extends BaseTestCase {
   public void testWithSlash() {
 
     EBasic basic = new EBasic("slash\\monkey");
-    Ebean.save(basic);
+    DB.save(basic);
 
-    Query<EBasic> query = Ebean.find(EBasic.class).where().startsWith("name", "slash\\mon").query();
+    Query<EBasic> query = DB.find(EBasic.class).where().startsWith("name", "slash\\mon").query();
     List<EBasic> list = query.findList();
 
     assertEquals(1, list.size());
 
-    Query<EBasic> query1 = Ebean.find(EBasic.class).where().like("name", "slash\\mon%").query();
+    Query<EBasic> query1 = DB.find(EBasic.class).where().like("name", "slash\\mon%").query();
     List<EBasic> list1 = query1.findList();
 
     if (!isMySql() && !isNuoDb() && !isMariaDB()) {
@@ -37,14 +37,14 @@ public class TestWhereLikeWithSlash extends BaseTestCase {
   public void testWithPipe() {
 
     EBasic basic = new EBasic("bash|monkey");
-    Ebean.save(basic);
+    DB.save(basic);
 
-    Query<EBasic> query = Ebean.find(EBasic.class).where().startsWith("name", "bash|mo").query();
+    Query<EBasic> query = DB.find(EBasic.class).where().startsWith("name", "bash|mo").query();
     List<EBasic> list = query.findList();
 
     assertEquals(1, list.size());
 
-    Query<EBasic> query1 = Ebean.find(EBasic.class).where().like("name", "bash|mon%").query();
+    Query<EBasic> query1 = DB.find(EBasic.class).where().like("name", "bash|mon%").query();
     List<EBasic> list1 = query1.findList();
 
     // This doesn't work in the latest version of H2 so disable for now.
@@ -56,19 +56,19 @@ public class TestWhereLikeWithSlash extends BaseTestCase {
   public void testWithOpenSquare() {
 
     EBasic basic = new EBasic("mash[monkey");
-    Ebean.save(basic);
+    DB.save(basic);
 
-    Query<EBasic> query = Ebean.find(EBasic.class).where().startsWith("name", "mash[mo").query();
+    Query<EBasic> query = DB.find(EBasic.class).where().startsWith("name", "mash[mo").query();
     List<EBasic> list = query.findList();
 
     assertEquals(1, list.size());
 
     List<EBasic> list1;
     if (isSqlServer()) {
-      list1 = Ebean.find(EBasic.class).where().like("name", "mash[[]mon%").query().findList();
+      list1 = DB.find(EBasic.class).where().like("name", "mash[[]mon%").query().findList();
 
     } else {
-      list1 = Ebean.find(EBasic.class).where().like("name", "mash[mon%").query().findList();
+      list1 = DB.find(EBasic.class).where().like("name", "mash[mon%").query().findList();
     }
 
     // This doesn't work in the latest version of H2 so disable for now.
diff --git a/ebean-core/src/test/java/org/tests/query/softdelete/TestSoftDeletePagingList.java b/ebean-test/src/test/java/org/tests/query/softdelete/TestSoftDeletePagingList.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/query/softdelete/TestSoftDeletePagingList.java
rename to ebean-test/src/test/java/org/tests/query/softdelete/TestSoftDeletePagingList.java
index e3fe57b18..01cc7a627 100644
--- a/ebean-core/src/test/java/org/tests/query/softdelete/TestSoftDeletePagingList.java
+++ b/ebean-test/src/test/java/org/tests/query/softdelete/TestSoftDeletePagingList.java
@@ -1,10 +1,10 @@
 package org.tests.query.softdelete;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.PagedList;
 import io.ebean.TransactionalTestCase;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.onetoone.album.Cover;
 
 import java.util.ArrayList;
@@ -22,12 +22,12 @@ public class TestSoftDeletePagingList extends TransactionalTestCase {
     list.add(new Cover("SoftDelPaged-2"));
     list.add(new Cover("SoftDelPaged-3"));
 
-    Ebean.saveAll(list);
-    Ebean.delete(list.get(1));
+    DB.saveAll(list);
+    DB.delete(list.get(1));
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    PagedList<Cover> pagedList = Ebean.find(Cover.class)
+    PagedList<Cover> pagedList = DB.find(Cover.class)
       .where().startsWith("s3Url", "SoftDelPaged-")
       .setMaxRows(10)
       .findPagedList();
@@ -35,7 +35,7 @@ public class TestSoftDeletePagingList extends TransactionalTestCase {
     int totalRowCount = pagedList.getTotalCount();
     List<Cover> resultList = pagedList.getList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(resultList).hasSize(2);
     assertThat(totalRowCount).isEqualTo(2);
diff --git a/ebean-core/src/test/java/org/tests/query/sqlquery/SqlQueryTests.java b/ebean-test/src/test/java/org/tests/query/sqlquery/SqlQueryTests.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/query/sqlquery/SqlQueryTests.java
rename to ebean-test/src/test/java/org/tests/query/sqlquery/SqlQueryTests.java
index f16828ec5..71501faa7 100644
--- a/ebean-core/src/test/java/org/tests/query/sqlquery/SqlQueryTests.java
+++ b/ebean-test/src/test/java/org/tests/query/sqlquery/SqlQueryTests.java
@@ -1,15 +1,11 @@
 package org.tests.query.sqlquery;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.RowMapper;
-import io.ebean.SqlQuery;
-import io.ebean.SqlRow;
+import io.ebean.*;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.meta.MetaTimedMetric;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
 
@@ -22,7 +18,7 @@ import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class SqlQueryTests extends BaseTestCase {
 
@@ -297,10 +293,10 @@ public class SqlQueryTests extends BaseTestCase {
     sqlQuery.setFirstRow(3);
     sqlQuery.setMaxRows(10);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     List<SqlRow> list = sqlQuery.findList();
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     if (isSqlServer()) {
       // FIXME: we should order by primary key ALWAYS (not by first column) when no
@@ -325,9 +321,9 @@ public class SqlQueryTests extends BaseTestCase {
       SqlQuery sqlQuery = DB.sqlQuery("Select * from o_order order by id");
       sqlQuery.setFirstRow(3);
 
-      LoggedSqlCollector.start();
+      LoggedSql.start();
       sqlQuery.findList();
-      List<String> sql = LoggedSqlCollector.stop();
+      List<String> sql = LoggedSql.stop();
 
       assertSql(sql.get(0)).contains("Select * from o_order order by id offset 3");
     }
@@ -341,9 +337,9 @@ public class SqlQueryTests extends BaseTestCase {
     SqlQuery sqlQuery = DB.sqlQuery("Select * from o_order order by id");
     sqlQuery.setMaxRows(10);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     sqlQuery.findList();
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     if (isSqlServer()) {
       assertSql(sql.get(0)).contains("Select * from o_order order by id offset 0 rows fetch next 10 rows only;");
@@ -367,9 +363,9 @@ public class SqlQueryTests extends BaseTestCase {
       .setLabel("findList-3-10");
 
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     sqlQuery.findList();
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     if (isSqlServer()) {
       assertSql(sql.get(0)).contains("select * from o_order where o_order.id > ? order by id offset 0 rows fetch next 10 rows only;");
@@ -393,9 +389,9 @@ public class SqlQueryTests extends BaseTestCase {
       .setMaxRows(10)
       .setLabel("findEach-Max10Rows");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     sqlQuery.findEach(bean -> bean.get("id"));
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     if (isSqlServer()) {
       assertSql(sql.get(0)).contains("offset 0 rows fetch next 10 rows only");
diff --git a/ebean-core/src/test/java/org/tests/query/sqlquery/TestNativeILikeExpression.java b/ebean-test/src/test/java/org/tests/query/sqlquery/TestNativeILikeExpression.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/query/sqlquery/TestNativeILikeExpression.java
rename to ebean-test/src/test/java/org/tests/query/sqlquery/TestNativeILikeExpression.java
index b3898dfad..66e9ce6bd 100644
--- a/ebean-core/src/test/java/org/tests/query/sqlquery/TestNativeILikeExpression.java
+++ b/ebean-test/src/test/java/org/tests/query/sqlquery/TestNativeILikeExpression.java
@@ -1,11 +1,11 @@
 package org.tests.query.sqlquery;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.annotation.Platform;
 import io.ebean.plugin.SpiServer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -22,7 +22,7 @@ public class TestNativeILikeExpression extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Query<Customer> query = Ebean.find(Customer.class)
+    Query<Customer> query = DB.find(Customer.class)
       .where().ilike("name", "rob")
       .query();
 
@@ -36,9 +36,9 @@ public class TestNativeILikeExpression extends BaseTestCase {
 
   private boolean isExpectNative() {
 
-    SpiServer pluginApi = server().getPluginApi();
-    boolean expressionNativeIlike = pluginApi.getServerConfig().isExpressionNativeIlike();
-    Platform platform = pluginApi.getPlatform().base();
+    SpiServer pluginApi = server().pluginApi();
+    boolean expressionNativeIlike = pluginApi.config().isExpressionNativeIlike();
+    Platform platform = pluginApi.platform().base();
 
     return expressionNativeIlike && platform == Platform.POSTGRES;
   }
diff --git a/ebean-core/src/test/java/org/tests/quotedidentifier/TestQuotedIdentifierQuery.java b/ebean-test/src/test/java/org/tests/quotedidentifier/TestQuotedIdentifierQuery.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/quotedidentifier/TestQuotedIdentifierQuery.java
rename to ebean-test/src/test/java/org/tests/quotedidentifier/TestQuotedIdentifierQuery.java
index caf230efc..b62e40121 100644
--- a/ebean-core/src/test/java/org/tests/quotedidentifier/TestQuotedIdentifierQuery.java
+++ b/ebean-test/src/test/java/org/tests/quotedidentifier/TestQuotedIdentifierQuery.java
@@ -1,8 +1,8 @@
 package org.tests.quotedidentifier;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.BWithQIdent;
 
 public class TestQuotedIdentifierQuery extends BaseTestCase {
@@ -14,11 +14,11 @@ public class TestQuotedIdentifierQuery extends BaseTestCase {
     bean.setName("foo");
     bean.setCODE("bar");
 
-    Ebean.save(bean);
+    DB.save(bean);
 
     if (isMySql()) {
 
-      Ebean.find(BWithQIdent.class)
+      DB.find(BWithQIdent.class)
         .where()
         .eq("name", "foo")
         .raw("t0.`Name` = ?", "foo")
@@ -27,7 +27,7 @@ public class TestQuotedIdentifierQuery extends BaseTestCase {
 
     } else if (isH2() || isPostgres()) {
 
-      Ebean.find(BWithQIdent.class)
+      DB.find(BWithQIdent.class)
         .where()
         .eq("name", "foo")
         .raw("t0.\"Name\" = ?", "foo")
diff --git a/ebean-core/src/test/java/org/tests/rawsql/A2Customer.java b/ebean-test/src/test/java/org/tests/rawsql/A2Customer.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/rawsql/A2Customer.java
rename to ebean-test/src/test/java/org/tests/rawsql/A2Customer.java
diff --git a/ebean-core/src/test/java/org/tests/rawsql/ACustomer.java b/ebean-test/src/test/java/org/tests/rawsql/ACustomer.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/rawsql/ACustomer.java
rename to ebean-test/src/test/java/org/tests/rawsql/ACustomer.java
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestInsertSqlLogging.java b/ebean-test/src/test/java/org/tests/rawsql/TestInsertSqlLogging.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/rawsql/TestInsertSqlLogging.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestInsertSqlLogging.java
index b8fdba507..f4c4c26b7 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestInsertSqlLogging.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestInsertSqlLogging.java
@@ -5,12 +5,12 @@ import io.ebean.DB;
 import io.ebean.SqlUpdate;
 import io.ebean.Transaction;
 import io.ebeaninternal.api.SpiTransaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.idkeys.db.AuditLog;
 
 import java.util.Arrays;
 
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 
 public class TestInsertSqlLogging extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestOrderReportTotal.java b/ebean-test/src/test/java/org/tests/rawsql/TestOrderReportTotal.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/rawsql/TestOrderReportTotal.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestOrderReportTotal.java
index 589bf6591..c6c541de7 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestOrderReportTotal.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestOrderReportTotal.java
@@ -1,19 +1,15 @@
 package org.tests.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.OrderAggregate;
 import org.tests.model.basic.OrderDetail;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestOrderReportTotal extends BaseTestCase {
 
@@ -24,19 +20,19 @@ public class TestOrderReportTotal extends BaseTestCase {
 
     RawSql rawSql = getRawSql();
 
-    Query<OrderAggregate> query = Ebean.createQuery(OrderAggregate.class);
+    Query<OrderAggregate> query = DB.createQuery(OrderAggregate.class);
 
     List<OrderAggregate> list = query.setRawSql(rawSql).findList();
     assertNotNull(list);
 
-    Query<OrderAggregate> q2 = Ebean.createQuery(OrderAggregate.class).setRawSql(rawSql);
+    Query<OrderAggregate> q2 = DB.createQuery(OrderAggregate.class).setRawSql(rawSql);
     q2.where().gt("id", 1);
     q2.having().gt("totalItems", 1);
 
     List<OrderAggregate> l2 = q2.findList();
     assertNotNull(l2);
 
-    Query<OrderAggregate> q3 = Ebean.createQuery(OrderAggregate.class).setRawSql(rawSql);
+    Query<OrderAggregate> q3 = DB.createQuery(OrderAggregate.class).setRawSql(rawSql);
     q3.where().eq("order_id", 1);
 
     OrderAggregate orderAggregate = q3.findOne();
@@ -57,7 +53,7 @@ public class TestOrderReportTotal extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    int detailsCount = Ebean.find(OrderDetail.class)
+    int detailsCount = DB.find(OrderDetail.class)
       .where()
       .gt("order.id", 2)
       .istartsWith("order.customer.name", "rob")
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlAsKeyword.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlAsKeyword.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlAsKeyword.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlAsKeyword.java
index 4e0fe97a1..9b9540003 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlAsKeyword.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlAsKeyword.java
@@ -1,17 +1,14 @@
 package org.tests.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestRawSqlAsKeyword extends BaseTestCase {
 
   @Test
@@ -34,13 +31,12 @@ public class TestRawSqlAsKeyword extends BaseTestCase {
         .parse("select r.id, r.name || 'hello' as name from o_customer r ")
         .create();
 
-    Query<Customer> query = Ebean.find(Customer.class);
+    Query<Customer> query = DB.find(Customer.class);
     query.setRawSql(rawSql);
     query.where().ilike("name", "r%");
 
     List<Customer> list = query.findList();
-    Assert.assertNotNull(list);
-
+    assertNotNull(list);
 
     // try valid query with no spaces
     rawSql =
@@ -48,34 +44,34 @@ public class TestRawSqlAsKeyword extends BaseTestCase {
         .parse("select r.id, r.name||'hello' as name from o_customer r ")
         .create();
 
-    query = Ebean.find(Customer.class);
+    query = DB.find(Customer.class);
     query.setRawSql(rawSql);
     query.where().ilike("name", "r%");
 
     list = query.findList();
-    Assert.assertNotNull(list);
+    assertNotNull(list);
 
     rawSql =
       RawSqlBuilder
         .parse("select r.id, r.name||'hello' name from o_customer r ")
         .create();
-    query = Ebean.find(Customer.class);
+    query = DB.find(Customer.class);
     query.setRawSql(rawSql);
     query.where().ilike("name", "r%");
 
     list = query.findList();
-    Assert.assertNotNull(list);
+    assertNotNull(list);
 
     // this will barf - expecting the AS keyword now
     rawSql =
       RawSqlBuilder
         .parse("select r.id, r.name || 'hello' name from o_customer r ")
         .create();
-    query = Ebean.find(Customer.class);
+    query = DB.find(Customer.class);
     query.setRawSql(rawSql);
     query.where().ilike("name", "r%");
 
     list = query.findList();
-    Assert.assertNotNull(list);
+    assertNotNull(list);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlCustomerAggregate.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlCustomerAggregate.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlCustomerAggregate.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlCustomerAggregate.java
index 1de360045..d61d4c8e4 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlCustomerAggregate.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlCustomerAggregate.java
@@ -1,17 +1,14 @@
 package org.tests.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.CustomerAggregate;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestRawSqlCustomerAggregate extends BaseTestCase {
 
   @Test
@@ -24,11 +21,11 @@ public class TestRawSqlCustomerAggregate extends BaseTestCase {
         "select c.customer_id, count(*) as totalContacts from contact c  group by c.customer_id")
       .columnMapping("c.customer_id", "customer.id").create();
 
-    Query<CustomerAggregate> query = Ebean.find(CustomerAggregate.class);
+    Query<CustomerAggregate> query = DB.find(CustomerAggregate.class);
     query.setRawSql(rawSql);
     query.where().ge("customer.id", 1);
 
     List<CustomerAggregate> list = query.findList();
-    Assert.assertNotNull(list);
+    assertNotNull(list);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlMasterDetail.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlMasterDetail.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlMasterDetail.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlMasterDetail.java
index 359bf2ebe..dcc81e2da 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlMasterDetail.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlMasterDetail.java
@@ -1,21 +1,17 @@
 package org.tests.rawsql;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.RawSql;
 import io.ebean.RawSqlBuilder;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.EBasic;
-import org.tests.model.basic.Order;
-import org.tests.model.basic.OrderDetail;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 
 import java.util.List;
 import java.util.Random;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestRawSqlMasterDetail extends BaseTestCase {
 
@@ -43,7 +39,7 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
       .columnMapping("t3.name", "details.product.name")
       .create();
 
-    List<Order> ordersFromRaw = Ebean.find(Order.class)
+    List<Order> ordersFromRaw = DB.find(Order.class)
       .setRawSql(rawSql)
       .setParameter("maxOrderId", 2)
       .setParameter("productId", 1)
@@ -67,7 +63,7 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
 
     RawSql rawSql = RawSqlBuilder.parse(rs).create();
 
-    List<Customer> customers = Ebean.find(Customer.class)
+    List<Customer> customers = DB.find(Customer.class)
       .setRawSql(rawSql)
       .findList();
 
@@ -89,7 +85,7 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
       .tableAliasMapping("ba", "billingAddress")
       .create();
 
-    List<Customer> customers = Ebean.find(Customer.class)
+    List<Customer> customers = DB.find(Customer.class)
       .setRawSql(rawSql)
       .findList();
 
@@ -112,7 +108,7 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
       .tableAliasMapping("sa", "shippingAddress")
       .create();
 
-    List<Customer> customers = Ebean.find(Customer.class)
+    List<Customer> customers = DB.find(Customer.class)
       .setRawSql(rawSql)
       .findList();
 
@@ -139,7 +135,7 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
       .tableAliasMapping("p", "details.product")
       .create();
 
-    List<Order> ordersFromRaw = Ebean.find(Order.class)
+    List<Order> ordersFromRaw = DB.find(Order.class)
       .setRawSql(rawSql)
       .setParameter("maxOrderId", 2)
       .setParameter("productId", 1)
@@ -157,13 +153,13 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
     basic.setName(name);
     basic.setStatus(EBasic.Status.ACTIVE);
 
-    Ebean.save(basic);
+    DB.save(basic);
 
     String rs = "select b.status, b.name from e_basic b ";
 
     RawSql rawSql = RawSqlBuilder.parse(rs).create();
 
-    List<EBasic> list = Ebean.find(EBasic.class)
+    List<EBasic> list = DB.find(EBasic.class)
       .setRawSql(rawSql)
       .where().eq("name", name)
       .findList();
@@ -172,7 +168,7 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
     EBasic basic1 = list.get(0);
     basic1.setDescription("insertAfterRawFetch");
 
-    Ebean.save(basic1);
+    DB.save(basic1);
   }
 
   @Test
@@ -185,7 +181,7 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
     RawSql rawSql = RawSqlBuilder.parse(rs)
       .create();
 
-    List<Order> ordersFromRaw = Ebean.find(Order.class)
+    List<Order> ordersFromRaw = DB.find(Order.class)
       .setRawSql(rawSql)
       .findList();
 
@@ -204,7 +200,7 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
     RawSql rawSql = RawSqlBuilder.parse(rs)
       .create();
 
-    List<Order> ordersFromRaw = Ebean.find(Order.class)
+    List<Order> ordersFromRaw = DB.find(Order.class)
       .setRawSql(rawSql)
       .findList();
 
@@ -227,7 +223,7 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
       .tableAliasMapping("o", null)
       .create();
 
-    List<Order> ordersFromRaw = Ebean.find(Order.class)
+    List<Order> ordersFromRaw = DB.find(Order.class)
       .setRawSql(rawSql)
       .findList();
 
@@ -256,7 +252,7 @@ public class TestRawSqlMasterDetail extends BaseTestCase {
       .tableAliasMapping("p", "details.product")
       .create();
 
-    List<Order> ordersFromRaw = Ebean.find(Order.class)
+    List<Order> ordersFromRaw = DB.find(Order.class)
       .setRawSql(rawSql)
       .findList();
 
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlNamedParams.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlNamedParams.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlNamedParams.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlNamedParams.java
index 62f3f3002..e40fe30bd 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlNamedParams.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlNamedParams.java
@@ -1,25 +1,18 @@
 package org.tests.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.CallableSql;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
-import io.ebean.Transaction;
+import io.ebean.*;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.sql.SQLException;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestRawSqlNamedParams extends BaseTestCase {
 
@@ -32,15 +25,14 @@ public class TestRawSqlNamedParams extends BaseTestCase {
       .parse("select r.id, r.name from o_customer r where r.id > :id and r.name like :name")
       .columnMapping("r.id", "id").columnMapping("r.name", "name").create();
 
-    Query<Customer> query = Ebean.find(Customer.class);
+    Query<Customer> query = DB.find(Customer.class);
     query.setRawSql(rawSql);
     query.setParameter("name", "R%");
     query.setParameter("id", 0);
     query.where().lt("id", 1000);
 
     List<Customer> list = query.findList();
-
-    Assert.assertNotNull(list);
+    assertNotNull(list);
   }
 
   @Test
@@ -49,29 +41,29 @@ public class TestRawSqlNamedParams extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Transaction transaction = Ebean.beginTransaction();
+    Transaction transaction = DB.beginTransaction();
 
     try {
-      if ("MariaDB connector/J".equals(transaction.getConnection().getMetaData().getDriverName())) {
+      if ("MariaDB connector/J".equals(transaction.connection().getMetaData().getDriverName())) {
         return; // MariaDb only supports callable statements in the form "? = call function x(?)"
       }
-      CallableSql callableSql = Ebean.createCallableSql("set @total = 0");
-      Ebean.execute(callableSql);
+      CallableSql callableSql = DB.createCallableSql("set @total = 0");
+      DB.getDefault().execute(callableSql);
 
       String sql = "select id, @total := 0 + id as total_items from o_order";
 
-      Query<Order> query1 = Ebean.findNative(Order.class, sql);
+      Query<Order> query1 = DB.findNative(Order.class, sql);
       List<Order> list = query1.findList();
 
       assertThat(list.get(0).getTotalItems()).isNotNull();
 
-      Ebean.execute(callableSql);
+      DB.getDefault().execute(callableSql);
 
       RawSql rawSql = RawSqlBuilder
         .parse(sql)
         .create();
 
-      Query<Order> query = Ebean.find(Order.class)
+      Query<Order> query = DB.find(Order.class)
         .setRawSql(rawSql);
 
       List<Order> list1 = query.findList();
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmQuery.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmQuery.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmQuery.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmQuery.java
index bece172f6..ac27ba981 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmQuery.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmQuery.java
@@ -1,18 +1,10 @@
 package org.tests.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
-import io.ebean.FutureRowCount;
-import io.ebean.PagedList;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
+import io.ebean.*;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
@@ -21,6 +13,8 @@ import java.util.List;
 import java.util.concurrent.ExecutionException;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestRawSqlOrmQuery extends BaseTestCase {
 
@@ -33,7 +27,7 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
       .columnMapping("r.id", "id")
       .columnMapping("r.name", "name").create();
 
-    Query<Customer> query = Ebean.find(Customer.class);
+    Query<Customer> query = DB.find(Customer.class);
     query.setRawSql(rawSql);
     query.where().ilike("name", "r%");
 
@@ -41,12 +35,12 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
     query.filterMany("contacts").gt("lastName", "b");
 
     List<Customer> list = query.findList();
-    Assert.assertNotNull(list);
+    assertNotNull(list);
 
     // check also select count(*)
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     assertThat(query.findCount()).isEqualTo(list.size());
-    List<String>sql = LoggedSqlCollector.stop();
+    List<String>sql = LoggedSql.stop();
     assertThat(sql.get(0)).startsWith("select count(*) from ( select r.id, r.name from o_customer r");
     assertThat(sql.get(0)).doesNotContain("order by");
   }
@@ -59,12 +53,12 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
 
     RawSql rawSql = RawSqlBuilder.parse("select id, NAME from O_CUSTOMER ").create();
 
-    Query<Customer> query = Ebean.find(Customer.class);
+    Query<Customer> query = DB.find(Customer.class);
     query.setRawSql(rawSql);
     query.where().ilike("name", "r%");
 
     List<Customer> list = query.findList();
-    Assert.assertNotNull(list);
+    assertNotNull(list);
   }
 
   @Test
@@ -79,7 +73,7 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
         .columnMapping("r.name", "name")
         .create();
 
-    Query<Customer> query = Ebean.find(Customer.class);
+    Query<Customer> query = DB.find(Customer.class);
     query.setRawSql(rawSql);
 
     int initialRowCount = query.findCount();
@@ -93,8 +87,8 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
     int rowCount = query.findCount();
     FutureRowCount<Customer> futureRowCount = query.findFutureCount();
 
-    Assert.assertEquals(initialRowCount, rowCount);
-    Assert.assertEquals(initialRowCount, futureRowCount.get().intValue());
+    assertEquals(initialRowCount, rowCount);
+    assertEquals(initialRowCount, futureRowCount.get().intValue());
 
     // check that lazy loading still executes
     for (Customer customer : list) {
@@ -113,7 +107,7 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
       .columnMapping("r.name", "name")
       .create();
 
-    Query<Customer> query = Ebean.find(Customer.class);
+    Query<Customer> query = DB.find(Customer.class);
     query.setRawSql(rawSql);
 
     int initialRowCount = query.findCount();
@@ -123,8 +117,8 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
     List<Customer> list = page.getList();
     int rowCount = page.getTotalCount();
 
-    Assert.assertEquals(2, list.size());
-    Assert.assertEquals(initialRowCount, rowCount);
+    assertEquals(2, list.size());
+    assertEquals(initialRowCount, rowCount);
 
     // check that lazy loading executes
     for (Customer customer : list) {
@@ -144,7 +138,7 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
       .columnMapping("o.ship_date", "shipDate")
       .create();
 
-    Query<Order> query = Ebean.find(Order.class);
+    Query<Order> query = DB.find(Order.class);
     query.setRawSql(rawSql);
 
     query.setMaxRows(100);
@@ -160,9 +154,9 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
     }
 
     // check also select count(*)
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.findCount();
-    List<String>sql = LoggedSqlCollector.stop();
+    List<String>sql = LoggedSql.stop();
     assertThat(sql.get(0)).startsWith("select count(*) from ( select o.id, o.order_date, o.ship_date from o_order o");
     assertThat(sql.get(0)).doesNotContain("order by");
   }
@@ -178,7 +172,7 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
       .columnMapping("o.ship_date", "shipDate")
       .create();
 
-    Query<Order> query = Ebean.find(Order.class);
+    Query<Order> query = DB.find(Order.class);
     query.setRawSql(rawSql);
     query.orderById(true);
 
@@ -195,9 +189,9 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
     }
 
     // check also select count(*)
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     query.findCount();
-    List<String>sql = LoggedSqlCollector.stop();
+    List<String>sql = LoggedSql.stop();
     assertThat(sql.get(0)).startsWith("select count(*) from ( select o.id, o.order_date, o.ship_date from o_order o");
     assertThat(sql.get(0)).doesNotContain("order by");
   }
@@ -214,7 +208,7 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
       .columnMapping("o.ship_date", "shipDate")
       .create();
 
-    Query<Order> query = Ebean.find(Order.class);
+    Query<Order> query = DB.find(Order.class);
     query.setRawSql(rawSql);
 
     query.setMaxRows(100);
@@ -246,7 +240,7 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
       .columnMapping("o.ship_date", "shipDate")
       .create();
 
-    Query<Order> query = Ebean.find(Order.class);
+    Query<Order> query = DB.find(Order.class);
     query.setRawSql(rawSql);
 
     query.setMaxRows(100);
@@ -278,7 +272,7 @@ public class TestRawSqlOrmQuery extends BaseTestCase {
       .columnMapping("o.ship_date", "shipDate")
       .create();
 
-    Query<Order> query = Ebean.find(Order.class);
+    Query<Order> query = DB.find(Order.class);
     query.setRawSql(rawSql);
 
     query.setMaxRows(100);
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmQueryDistinct.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmQueryDistinct.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmQueryDistinct.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmQueryDistinct.java
index 19c53d44d..9e834e98f 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmQueryDistinct.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmQueryDistinct.java
@@ -1,18 +1,14 @@
 package org.tests.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestRawSqlOrmQueryDistinct extends BaseTestCase {
 
   @Test
@@ -23,14 +19,14 @@ public class TestRawSqlOrmQueryDistinct extends BaseTestCase {
     RawSql rawSql0 = RawSqlBuilder.parse(" select  distinct  r.id, r.name from o_customer r ")
       .create();
 
-    Query<Customer> query0 = Ebean.find(Customer.class);
+    Query<Customer> query0 = DB.find(Customer.class);
     query0.setRawSql(rawSql0);
     query0.where().ilike("name", "r%");
 
     RawSql rawSql = RawSqlBuilder.parse(" select  distinct  r.id, r.name from o_customer r ")
       .columnMapping("r.id", "id").columnMapping("r.name", "name").create();
 
-    Query<Customer> query = Ebean.find(Customer.class);
+    Query<Customer> query = DB.find(Customer.class);
     query.setRawSql(rawSql);
     query.where().ilike("name", "r%");
 
@@ -38,7 +34,7 @@ public class TestRawSqlOrmQueryDistinct extends BaseTestCase {
     query.filterMany("contacts").gt("lastName", "b");
 
     List<Customer> list = query.findList();
-    Assert.assertNotNull(list);
+    assertNotNull(list);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper.java
index a012e5e5e..aa8048769 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper.java
@@ -1,19 +1,16 @@
 package org.tests.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderAggregate;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestRawSqlOrmWrapper extends BaseTestCase {
 
   @Test
@@ -33,17 +30,17 @@ public class TestRawSqlOrmWrapper extends BaseTestCase {
       // .columnMapping("sum(d.order_qty*d.unit_price)", "totalAmount")
       .create();
 
-    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class);
+    Query<OrderAggregate> query = DB.find(OrderAggregate.class);
     query.setRawSql(rawSql)
       // .fetch("order.details", new FetchConfig().query())
       .where().gt("order.id", 0).having().gt("totalAmount", 20);
 
     List<OrderAggregate> list = query.findList();
-    Assert.assertNotNull(list);
+    assertNotNull(list);
 
     output(list);
 
-    List<OrderAggregate> list2 = Ebean.find(OrderAggregate.class).setRawSql(rawSql)
+    List<OrderAggregate> list2 = DB.find(OrderAggregate.class).setRawSql(rawSql)
       // .fetch("order.details", new FetchConfig().query())
       .where().gt("order.id", 2).having().gt("totalAmount", 10).findList();
 
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper2.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper2.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper2.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper2.java
index 94df85a74..8e477055c 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper2.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper2.java
@@ -1,19 +1,15 @@
 package org.tests.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
-import io.ebean.Query;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderAggregate;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestRawSqlOrmWrapper2 extends BaseTestCase {
 
   @Test
@@ -30,19 +26,18 @@ public class TestRawSqlOrmWrapper2 extends BaseTestCase {
       // .columnMapping("sum(d.order_qty*d.unit_price)", "totalAmount")
       .create();
 
-    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class);
+    Query<OrderAggregate> query = DB.find(OrderAggregate.class);
     query.setRawSql(rawSql).fetchQuery("order", "status,orderDate")
       .fetch("order.customer", "name").where().gt("order.id", 0).having().gt("totalAmount", 20)
       .order().desc("totalAmount").setMaxRows(10);
 
     List<OrderAggregate> list = query.findList();
-    Assert.assertNotNull(list);
+    assertNotNull(list);
 
     for (OrderAggregate oa : list) {
       oa.getTotalAmount();
       Order order = oa.getOrder();
       order.getId();
     }
-
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper3.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper3.java
similarity index 91%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper3.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper3.java
index 3e3bc2e20..404b12861 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper3.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlOrmWrapper3.java
@@ -1,15 +1,14 @@
 package org.tests.rawsql;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
 import io.ebean.RawSql;
 import io.ebean.RawSqlBuilder;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.OrderAggregate;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -32,7 +31,7 @@ public class TestRawSqlOrmWrapper3 extends BaseTestCase {
       // .columnMapping("sum(d.order_qty*d.unit_price)", "totalAmount")
       .create();
 
-    List<OrderAggregate> list2 = Ebean.find(OrderAggregate.class).setRawSql(rawSql)
+    List<OrderAggregate> list2 = DB.find(OrderAggregate.class).setRawSql(rawSql)
       .fetchQuery("order")
       .fetchQuery("order.details")
       .where().gt("order.id", 2)
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlPositionedParams.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlPositionedParams.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlPositionedParams.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlPositionedParams.java
index 75d678fd6..6444593e6 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlPositionedParams.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlPositionedParams.java
@@ -4,7 +4,7 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.RawSql;
 import io.ebean.RawSqlBuilder;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlUnparsedQuery.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlUnparsedQuery.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlUnparsedQuery.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlUnparsedQuery.java
index 1e576f0b7..61942668e 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlUnparsedQuery.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlUnparsedQuery.java
@@ -4,7 +4,7 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.RawSql;
 import io.ebean.RawSqlBuilder;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
diff --git a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlWithResultSet.java b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlWithResultSet.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/rawsql/TestRawSqlWithResultSet.java
rename to ebean-test/src/test/java/org/tests/rawsql/TestRawSqlWithResultSet.java
index 300ecd524..59a2bfa81 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/TestRawSqlWithResultSet.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/TestRawSqlWithResultSet.java
@@ -1,14 +1,9 @@
 package org.tests.rawsql;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
-import io.ebean.RawSql;
-import io.ebean.RawSqlBuilder;
-import io.ebean.Transaction;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
@@ -27,16 +22,16 @@ public class TestRawSqlWithResultSet extends BaseTestCase {
     PreparedStatement pstmt = null;
 
     // Transaction supplies our jdbc Connection
-    Transaction txn = Ebean.beginTransaction();
+    Transaction txn = DB.beginTransaction();
     try {
-      pstmt = txn.getConnection().prepareStatement("select id, name, billing_address_id from o_customer");
+      pstmt = txn.connection().prepareStatement("select id, name, billing_address_id from o_customer");
 
       // ResultSet will be closed by Ebean
       ResultSet resultSet = pstmt.executeQuery();
 
       RawSql rawSql = RawSqlBuilder.resultSet(resultSet, "id", "name", "billingAddress.id");
 
-      List<Customer> list = Ebean.find(Customer.class)
+      List<Customer> list = DB.find(Customer.class)
         .setRawSql(rawSql)
         // also test a secondary query join
         .fetchQuery("billingAddress")
diff --git a/ebean-core/src/test/java/org/tests/rawsql/inherit/ParentQueryTest.java b/ebean-test/src/test/java/org/tests/rawsql/inherit/ParentQueryTest.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/rawsql/inherit/ParentQueryTest.java
rename to ebean-test/src/test/java/org/tests/rawsql/inherit/ParentQueryTest.java
index 38dc54918..b3e879e71 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/inherit/ParentQueryTest.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/inherit/ParentQueryTest.java
@@ -2,19 +2,18 @@ package org.tests.rawsql.inherit;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
+import org.junit.jupiter.api.Test;
 import org.tests.inherit.ChildA;
 import org.tests.inherit.ChildB;
 import org.tests.inherit.Data;
 import org.tests.inherit.Parent;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class ParentQueryTest extends BaseTestCase {
 
@@ -28,17 +27,17 @@ public class ParentQueryTest extends BaseTestCase {
 
     ChildA a = new ChildA(1000, "PQT-PA");
     a.setData(exampleData);
-    Ebean.save(a);
+    DB.save(a);
 
     ChildB b = new ChildB(1001, "PQT-PB");
     b.setData(exampleData);
-    Ebean.save(b);
+    DB.save(b);
 
     ChildA c = new ChildA(1002, "PQT-PC");
     c.setData(exampleData);
-    Ebean.save(c);
+    DB.save(c);
 
-    List<Parent> partial = Ebean.find(Parent.class).where().ge("val", 1001).findList();
+    List<Parent> partial = DB.find(Parent.class).where().ge("val", 1001).findList();
     assertNotNull(partial.get(0).getData());
     assertThat(partial.get(0).getMore()).startsWith("PQT-");
     assertEquals(partial.get(0).getData().get(0).getVal().intValue(), 0);
diff --git a/ebean-core/src/test/java/org/tests/rawsql/inherit/ParentRawSqlTest.java b/ebean-test/src/test/java/org/tests/rawsql/inherit/ParentRawSqlTest.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/rawsql/inherit/ParentRawSqlTest.java
rename to ebean-test/src/test/java/org/tests/rawsql/inherit/ParentRawSqlTest.java
index e410bb9af..0369ba346 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/inherit/ParentRawSqlTest.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/inherit/ParentRawSqlTest.java
@@ -1,35 +1,27 @@
 package org.tests.rawsql.inherit;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.FetchConfig;
+import io.ebean.DB;
 import io.ebean.RawSql;
 import io.ebean.RawSqlBuilder;
-import org.junit.Before;
-import org.junit.Test;
-import org.tests.inherit.ChildA;
-import org.tests.inherit.ChildB;
-import org.tests.inherit.Data;
-import org.tests.inherit.EUncle;
-import org.tests.inherit.Parent;
-import org.tests.inherit.ParentAggregate;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.tests.inherit.*;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ParentRawSqlTest extends BaseTestCase {
 
-  @Before
+  @BeforeEach
   public void clearDb() {
-    Ebean.deleteAll(Ebean.find(Data.class).findList());
-    Ebean.deleteAll(Ebean.find(Parent.class).findList());
+    DB.deleteAll(DB.find(Data.class).findList());
+    DB.deleteAll(DB.find(Parent.class).findList());
     //@rob: this does not work as it does not clear the ManyToMany relations.
-//    Ebean.find(Data.class).delete();
-//    Ebean.find(Parent.class).delete();
+//    DB.find(Data.class).delete();
+//    DB.find(Parent.class).delete();
   }
 
   @Test
@@ -42,21 +34,21 @@ public class ParentRawSqlTest extends BaseTestCase {
 
     ChildA a = new ChildA(0, "PA");
     a.setData(exampleData);
-    Ebean.save(a);
+    DB.save(a);
 
     ChildB b = new ChildB(1, "PB");
     b.setData(exampleData);
-    Ebean.save(b);
+    DB.save(b);
 
     ChildA c = new ChildA(2, "PC");
     c.setData(exampleData);
-    Ebean.save(c);
+    DB.save(c);
 
     RawSql rawSql = RawSqlBuilder
       .parse("select type, id, val from rawinherit_parent where val > 1")
       .create();
 
-    List<Parent> partial = Ebean.find(Parent.class)
+    List<Parent> partial = DB.find(Parent.class)
       .setRawSql(rawSql)
       .findList();
 
@@ -74,20 +66,20 @@ public class ParentRawSqlTest extends BaseTestCase {
 
     ChildA a = new ChildA(0, "PA");
     a.setData(exampleData);
-    Ebean.save(a);
+    DB.save(a);
 
     ChildB b = new ChildB(1, "PB");
     b.setData(exampleData);
-    Ebean.save(b);
+    DB.save(b);
 
     ChildA c = new ChildA(2, "PC");
     c.setData(exampleData);
-    Ebean.save(c);
+    DB.save(c);
 
     EUncle e1 = new EUncle();
     e1.setParent(b);
     e1.setName("fester");
-    Ebean.save(e1);
+    DB.save(e1);
 
     joinToInheritanceHierarchy_withAliasMapping();
     joinToInheritanceHierarchy_bug416();
@@ -113,7 +105,7 @@ public class ParentRawSqlTest extends BaseTestCase {
       .columnMapping("p_more", "parent.more")
       .create();
 
-    List<EUncle> uncles = Ebean.find(EUncle.class).setRawSql(rawSql).findList();
+    List<EUncle> uncles = DB.find(EUncle.class).setRawSql(rawSql).findList();
 
     assertNotNull(uncles.get(0));
     Parent parent = uncles.get(0).getParent();
@@ -130,7 +122,7 @@ public class ParentRawSqlTest extends BaseTestCase {
       .columnMapping("p_id", "parent.id")
       .create();
 
-    List<EUncle> uncles = Ebean.find(EUncle.class).setRawSql(rawSql)
+    List<EUncle> uncles = DB.find(EUncle.class).setRawSql(rawSql)
       .fetchQuery("parent")
       .findList();
 
@@ -149,7 +141,7 @@ public class ParentRawSqlTest extends BaseTestCase {
       .columnMapping("pid", "parent.id")
       .create();
 
-    List<EUncle> uncles = Ebean.find(EUncle.class).setRawSql(rawSql)
+    List<EUncle> uncles = DB.find(EUncle.class).setRawSql(rawSql)
       .fetchQuery("parent")
       .findList();
 
@@ -165,7 +157,7 @@ public class ParentRawSqlTest extends BaseTestCase {
       .tableAliasMapping("p", "parent")
       .create();
 
-    List<EUncle> uncles = Ebean.find(EUncle.class).setRawSql(rawSql)
+    List<EUncle> uncles = DB.find(EUncle.class).setRawSql(rawSql)
       .findList();
 
     assertNotNull(uncles.get(0));
@@ -184,7 +176,7 @@ public class ParentRawSqlTest extends BaseTestCase {
       .columnMapping("id", "parent.id")
       .create();
 
-    List<ParentAggregate> aggregates = Ebean.find(ParentAggregate.class).setRawSql(rawSql)
+    List<ParentAggregate> aggregates = DB.find(ParentAggregate.class).setRawSql(rawSql)
       .fetchQuery("parent")
       .findList();
 
@@ -208,7 +200,7 @@ public class ParentRawSqlTest extends BaseTestCase {
       .columnMapping("id", "parent.id")
       .create();
 
-    List<ParentAggregate> aggregates = Ebean.find(ParentAggregate.class).setRawSql(rawSql)
+    List<ParentAggregate> aggregates = DB.find(ParentAggregate.class).setRawSql(rawSql)
       .fetchQuery("parent")
       .findList();
 
@@ -234,7 +226,7 @@ public class ParentRawSqlTest extends BaseTestCase {
       .columnMappingIgnore("b") // extra ignore after
       .create();
 
-    List<ParentAggregate> aggregates = Ebean.find(ParentAggregate.class).setRawSql(rawSql)
+    List<ParentAggregate> aggregates = DB.find(ParentAggregate.class).setRawSql(rawSql)
       .fetchQuery("parent")
       .findList();
 
diff --git a/ebean-core/src/test/java/org/tests/rawsql/nativesql/TestNativeSqlBasic.java b/ebean-test/src/test/java/org/tests/rawsql/nativesql/TestNativeSqlBasic.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/rawsql/nativesql/TestNativeSqlBasic.java
rename to ebean-test/src/test/java/org/tests/rawsql/nativesql/TestNativeSqlBasic.java
index 4e0ccfd02..f73ce824b 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/nativesql/TestNativeSqlBasic.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/nativesql/TestNativeSqlBasic.java
@@ -2,12 +2,12 @@ package org.tests.rawsql.nativesql;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
@@ -25,13 +25,13 @@ public class TestNativeSqlBasic extends BaseTestCase {
 
     String nativeSql = "select id, name from o_customer";
 
-    Query<Customer> query = Ebean.findNative(Customer.class, nativeSql);
+    Query<Customer> query = DB.findNative(Customer.class, nativeSql);
 
     List<Customer> customers = query.findList();
     assertThat(customers).isNotEmpty();
 
-    BeanState beanState = Ebean.getBeanState(customers.get(0));
-    assertThat(beanState.getLoadedProps()).contains("id", "name");
+    BeanState beanState = DB.beanState(customers.get(0));
+    assertThat(beanState.loadedProps()).contains("id", "name");
   }
 
   @Test
@@ -40,13 +40,13 @@ public class TestNativeSqlBasic extends BaseTestCase {
     ResetBasicData.reset();
 
     String nativeSql = "select * from o_customer";
-    Query<Customer> query = Ebean.findNative(Customer.class, nativeSql);
+    Query<Customer> query = DB.findNative(Customer.class, nativeSql);
 
     List<Customer> customers = query.findList();
     assertThat(customers).isNotEmpty();
 
-    BeanState beanState = Ebean.getBeanState(customers.get(0));
-    assertThat(beanState.getLoadedProps().size()).isGreaterThan(10);
+    BeanState beanState = DB.beanState(customers.get(0));
+    assertThat(beanState.loadedProps().size()).isGreaterThan(10);
   }
 
   @Test
@@ -55,7 +55,7 @@ public class TestNativeSqlBasic extends BaseTestCase {
     ResetBasicData.reset();
 
     String nativeSql = "select c.*, b.city from o_customer c join o_address b on b.id = c.billing_address_id";
-    Query<Customer> query = Ebean.findNative(Customer.class, nativeSql);
+    Query<Customer> query = DB.findNative(Customer.class, nativeSql);
 
     List<Customer> customers = query.findList();
     assertThat(customers).isNotEmpty();
@@ -68,13 +68,13 @@ public class TestNativeSqlBasic extends BaseTestCase {
 
     String nativeSql = "select id, name from o_customer where id > :some";
 
-    Query<Customer> query = Ebean.findNative(Customer.class, nativeSql);
+    Query<Customer> query = DB.findNative(Customer.class, nativeSql);
     query.setParameter("some", 1);
 
     List<Customer> customers = query.findList();
     assertThat(customers).isNotEmpty();
 
-    Query<Customer> query2 = Ebean.findNative(Customer.class, nativeSql);
+    Query<Customer> query2 = DB.findNative(Customer.class, nativeSql);
     query2.setParameter("some", 2);
 
     List<Customer> customers2 = query2.findList();
@@ -88,7 +88,7 @@ public class TestNativeSqlBasic extends BaseTestCase {
 
     String nativeSql = "select id, name from o_customer where id > :some";
 
-    Query<Customer> query = Ebean.findNative(Customer.class, nativeSql)
+    Query<Customer> query = DB.findNative(Customer.class, nativeSql)
       .setParameter("some", 1)
       .setMaxRows(10);
 
@@ -106,7 +106,7 @@ public class TestNativeSqlBasic extends BaseTestCase {
 
     String nativeSql = "select id, name from o_customer where id > :some";
 
-    Query<Customer> query = Ebean.findNative(Customer.class, nativeSql)
+    Query<Customer> query = DB.findNative(Customer.class, nativeSql)
       .setParameter("some", 1)
       .setFirstRow(20)
       .setMaxRows(10);
@@ -126,7 +126,7 @@ public class TestNativeSqlBasic extends BaseTestCase {
 
     String nativeSql = "select id, name from o_customer where id > ?";
 
-    List<Customer> customers = Ebean.findNative(Customer.class, nativeSql)
+    List<Customer> customers = DB.findNative(Customer.class, nativeSql)
       .setParameter(1)
       .findList();
 
@@ -146,7 +146,7 @@ public class TestNativeSqlBasic extends BaseTestCase {
 
     String nativeSql = "select o.id, o.status, c.id, c.name, c.version from o_order o join o_customer c on c.id = o.kcustomer_id ";
 
-    List<Order> orders = Ebean.findNative(Order.class, nativeSql)
+    List<Order> orders = DB.findNative(Order.class, nativeSql)
       .findList();
 
     for (Order order : orders) {
@@ -157,28 +157,27 @@ public class TestNativeSqlBasic extends BaseTestCase {
 
   @Test
   public void partialAssocIncludingOracle() {
-
     ResetBasicData.reset();
+    DB.cacheManager().clearAll();
 
     String nativeSql = "select o.id, o.status, o.kcustomer_id from o_order o";
-
-    List<Order> orders = Ebean.findNative(Order.class, nativeSql)
+    List<Order> orders = DB.findNative(Order.class, nativeSql)
       .findList();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     for (Order order : orders) {
       order.getStatus();
     }
 
-    List<String> sql = LoggedSqlCollector.current();
+    List<String> sql = LoggedSql.collect();
     assertThat(sql).isEmpty();
 
     for (Order order : orders) {
       order.getCustomer().getName();
     }
 
-    sql = LoggedSqlCollector.stop();
+    sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains(" from o_customer t0 where ");
   }
@@ -190,15 +189,15 @@ public class TestNativeSqlBasic extends BaseTestCase {
 
     String nativeSql = "select * from o_customer where id > ?";
     List<Customer> customers =
-        Ebean.findNative(Customer.class, nativeSql)
+        DB.findNative(Customer.class, nativeSql)
         .setParameter(1)
         .fetchQuery("contacts")
         .findList();
 
     assertThat(customers).isNotEmpty();
 
-    BeanState beanState = Ebean.getBeanState(customers.get(0));
-    assertThat(beanState.getLoadedProps().size()).isGreaterThan(10);
+    BeanState beanState = DB.beanState(customers.get(0));
+    assertThat(beanState.loadedProps().size()).isGreaterThan(10);
   }
 
   @Test
@@ -208,12 +207,12 @@ public class TestNativeSqlBasic extends BaseTestCase {
 
     String nativeSql = "select c.id, 'foo' as name from o_customer c";
     List<Customer> customers =
-      Ebean.findNative(Customer.class, nativeSql)
+      DB.findNative(Customer.class, nativeSql)
         .findList();
 
     assertThat(customers).isNotEmpty();
 
-    BeanState beanState = Ebean.getBeanState(customers.get(0));
-    assertThat(beanState.getLoadedProps()).contains("id", "name");
+    BeanState beanState = DB.beanState(customers.get(0));
+    assertThat(beanState.loadedProps()).contains("id", "name");
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/rawsql/nativesql/TestNativeWithEmbedded.java b/ebean-test/src/test/java/org/tests/rawsql/nativesql/TestNativeWithEmbedded.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/rawsql/nativesql/TestNativeWithEmbedded.java
rename to ebean-test/src/test/java/org/tests/rawsql/nativesql/TestNativeWithEmbedded.java
index 39f63c31b..991f66724 100644
--- a/ebean-core/src/test/java/org/tests/rawsql/nativesql/TestNativeWithEmbedded.java
+++ b/ebean-test/src/test/java/org/tests/rawsql/nativesql/TestNativeWithEmbedded.java
@@ -3,8 +3,8 @@ package org.tests.rawsql.nativesql;
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Query;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.embedded.EAddress;
 import org.tests.model.embedded.EPerson;
 import org.tests.model.json.PlainBean;
@@ -35,7 +35,7 @@ public class TestNativeWithEmbedded extends BaseTestCase {
 
     String sql = "select id, name, street, suburb, addr_city, addr_status, addr_jbean, jraw from eperson where id = ?";
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Query<EPerson> query = DB.findNative(EPerson.class, sql);
     query.setParameter(person.getId());
@@ -46,7 +46,7 @@ public class TestNativeWithEmbedded extends BaseTestCase {
     assertThat(one.getAddress().getJbean().getName()).isEqualTo("hi");
     assertThat(one.getAddress().getJraw().get("a")).isEqualTo("1");
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/readaudit/TestReadAudit.java b/ebean-test/src/test/java/org/tests/readaudit/TestReadAudit.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/readaudit/TestReadAudit.java
rename to ebean-test/src/test/java/org/tests/readaudit/TestReadAudit.java
index 98f24353b..2b1a2740d 100644
--- a/ebean-core/src/test/java/org/tests/readaudit/TestReadAudit.java
+++ b/ebean-test/src/test/java/org/tests/readaudit/TestReadAudit.java
@@ -11,18 +11,14 @@ import io.ebean.event.readaudit.ReadAuditLogger;
 import io.ebean.event.readaudit.ReadAuditPrepare;
 import io.ebean.event.readaudit.ReadAuditQueryPlan;
 import io.ebean.event.readaudit.ReadEvent;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.EBasicChangeLog;
 
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -39,7 +35,7 @@ public class TestReadAudit extends BaseTestCase {
   Long id1;
   Long id2;
 
-  @Before
+  @BeforeEach
   public void setup() {
     server = createServer();
 
@@ -61,7 +57,7 @@ public class TestReadAudit extends BaseTestCase {
     server.save(ar);
   }
 
-  @After
+  @AfterEach
   public void shutdown() {
     server.shutdown();
   }
@@ -83,8 +79,8 @@ public class TestReadAudit extends BaseTestCase {
   public void test_findById_usingL2Cache() {
     resetCounters();
 
-    ServerCache beanCache = server.getServerCacheManager().getBeanCache(EBasicChangeLog.class);
-    beanCache.getStatistics(true);
+    ServerCache beanCache = server.cacheManager().beanCache(EBasicChangeLog.class);
+    beanCache.statistics(true);
 
     EBasicChangeLog found = server.find(EBasicChangeLog.class, id1);
     assertThat(found).isNotNull();
@@ -94,13 +90,13 @@ public class TestReadAudit extends BaseTestCase {
     assertThat(readAuditLogger.beans.get(0).getBeanType()).isEqualTo(EBasicChangeLog.class.getName());
     assertThat(readAuditLogger.beans.get(0).getId()).isEqualTo(id1);
 
-    ServerCacheStatistics statistics = beanCache.getStatistics(false);
+    ServerCacheStatistics statistics = beanCache.statistics(false);
     assertThat(statistics.getSize()).isEqualTo(1);
     assertThat(statistics.getHitCount()).isEqualTo(0);
 
     EBasicChangeLog found2 = server.find(EBasicChangeLog.class, id1);
     assertThat(found2).isNotNull();
-    statistics = beanCache.getStatistics(false);
+    statistics = beanCache.statistics(false);
     assertThat(statistics.getSize()).isEqualTo(1);
     assertThat(statistics.getHitCount()).isEqualTo(1);
 
@@ -111,8 +107,8 @@ public class TestReadAudit extends BaseTestCase {
   public void test_findById_usingL2Cache_sharedBean() {
     resetCounters();
 
-    ServerCache beanCache = server.getServerCacheManager().getBeanCache(Country.class);
-    beanCache.getStatistics(true);
+    ServerCache beanCache = server.cacheManager().beanCache(Country.class);
+    beanCache.statistics(true);
 
     Country found = server.find(Country.class, "AR");
     assertThat(found).isNotNull();
@@ -122,19 +118,19 @@ public class TestReadAudit extends BaseTestCase {
     assertThat(readAuditLogger.beans.get(0).getBeanType()).isEqualTo(Country.class.getName());
     assertThat(readAuditLogger.beans.get(0).getId()).isEqualTo("AR");
 
-    ServerCacheStatistics statistics = beanCache.getStatistics(false);
+    ServerCacheStatistics statistics = beanCache.statistics(false);
     assertThat(statistics.getSize()).isEqualTo(1);
     assertThat(statistics.getHitCount()).isEqualTo(0);
 
     Country found2 = server.find(Country.class, "AR");
     assertThat(found2).isNotNull();
-    statistics = beanCache.getStatistics(false);
+    statistics = beanCache.statistics(false);
     assertThat(statistics.getSize()).isEqualTo(1);
     assertThat(statistics.getHitCount()).isEqualTo(1);
 
     assertThat(readAuditLogger.beans).hasSize(2);
 
-    Country ref = server.getReference(Country.class, "AR");
+    Country ref = server.reference(Country.class, "AR");
     assertThat(readAuditLogger.beans).hasSize(3);
     assertThat(ref).isSameAs(found2);
   }
@@ -169,7 +165,7 @@ public class TestReadAudit extends BaseTestCase {
 
     resetCounters();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<EBasicChangeLog> list = server.find(EBasicChangeLog.class)
       .setUseQueryCache(true)
@@ -192,7 +188,7 @@ public class TestReadAudit extends BaseTestCase {
 
     System.out.println("test_findList_useL2Cache> second query " + list1.size());
     assertThat(list1).hasSize(2);
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     System.out.println("test_findList_useL2Cache> sql: " + sql);
     //assertThat(sql).hasSize(1);
 
diff --git a/ebean-core/src/test/java/org/tests/refresh/TestRefreshWithMany.java b/ebean-test/src/test/java/org/tests/refresh/TestRefreshWithMany.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/refresh/TestRefreshWithMany.java
rename to ebean-test/src/test/java/org/tests/refresh/TestRefreshWithMany.java
index 65ca483f8..078839f6a 100644
--- a/ebean-core/src/test/java/org/tests/refresh/TestRefreshWithMany.java
+++ b/ebean-test/src/test/java/org/tests/refresh/TestRefreshWithMany.java
@@ -1,18 +1,16 @@
 package org.tests.refresh;
 
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.SqlRow;
 import io.ebean.TransactionalTestCase;
-
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestRefreshWithMany extends TransactionalTestCase {
 
@@ -22,23 +20,23 @@ public class TestRefreshWithMany extends TransactionalTestCase {
 
     Customer customer = ResetBasicData.createCustomer("refresher", "22 refresh set", "23 fresh", 9);
 
-    Ebean.save(customer);
+    DB.save(customer);
 
     assertEquals(3, customer.getContacts().size());
 
-    int rc = Ebean.createSqlUpdate("update o_customer set name = :name where id = :id")
+    int rc = DB.sqlUpdate("update o_customer set name = :name where id = :id")
       .setParameter("name", "ref-modified")
       .setParameter("id", customer.getId())
       .execute();
 
-    int rc2 = Ebean.createSqlUpdate("update contact set first_name = concat(first_name,'-mod') where customer_id = :id")
+    int rc2 = DB.sqlUpdate("update contact set first_name = concat(first_name,'-mod') where customer_id = :id")
       .setParameter("id", customer.getId())
       .execute();
 
     assertEquals(1, rc);
     assertEquals(3, rc2);
 
-    Ebean.refresh(customer);
+    DB.refresh(customer);
 
     assertEquals("ref-modified", customer.getName());
     assertEquals(3, customer.getContacts().size());
@@ -46,18 +44,18 @@ public class TestRefreshWithMany extends TransactionalTestCase {
 
 
     // now try again when the bean is fully loaded
-    Customer customer1 = Ebean.find(Customer.class)
+    Customer customer1 = DB.find(Customer.class)
       .fetch("contacts")
       .setId(customer.getId())
       .findOne();
 
 
-    int rcb1 = Ebean.createSqlUpdate("update o_customer set name = :name where id = :id")
+    int rcb1 = DB.sqlUpdate("update o_customer set name = :name where id = :id")
       .setParameter("name", "ref-modified-again")
       .setParameter("id", customer.getId())
       .execute();
 
-    int rcb2 = Ebean.createSqlUpdate("update contact set first_name = :first, last_name='foo' where customer_id = :id")
+    int rcb2 = DB.sqlUpdate("update contact set first_name = :first, last_name='foo' where customer_id = :id")
       .setParameter("id", customer.getId())
       .setParameter("first", "-alt")
       .execute();
@@ -72,7 +70,7 @@ public class TestRefreshWithMany extends TransactionalTestCase {
     assertEquals(1, rcb1);
     assertEquals(3, rcb2);
 
-    Ebean.refresh(customer1);
+    DB.refresh(customer1);
 
     assertEquals("ref-modified-again", customer1.getName());
     assertEquals(3, customer1.getContacts().size());
diff --git a/ebean-core/src/test/java/org/tests/repository/CustomerRepository.java b/ebean-test/src/test/java/org/tests/repository/CustomerRepository.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/repository/CustomerRepository.java
rename to ebean-test/src/test/java/org/tests/repository/CustomerRepository.java
index 5d62f3fd6..f9fc7f59b 100644
--- a/ebean-core/src/test/java/org/tests/repository/CustomerRepository.java
+++ b/ebean-test/src/test/java/org/tests/repository/CustomerRepository.java
@@ -1,7 +1,7 @@
 package org.tests.repository;
 
 import io.ebean.BeanRepository;
-import io.ebean.EbeanServer;
+import io.ebean.Database;
 import org.tests.model.basic.Customer;
 
 import java.util.List;
@@ -11,7 +11,7 @@ import java.util.List;
 public class CustomerRepository extends BeanRepository<Integer, Customer> {
 
   //@Inject
-  public CustomerRepository(EbeanServer server) {
+  public CustomerRepository(Database server) {
     super(Customer.class, server);
   }
 
diff --git a/ebean-core/src/test/java/org/tests/repository/TestBeanRepository.java b/ebean-test/src/test/java/org/tests/repository/TestBeanRepository.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/repository/TestBeanRepository.java
rename to ebean-test/src/test/java/org/tests/repository/TestBeanRepository.java
index 6bb90a87d..f09823412 100644
--- a/ebean-core/src/test/java/org/tests/repository/TestBeanRepository.java
+++ b/ebean-test/src/test/java/org/tests/repository/TestBeanRepository.java
@@ -2,7 +2,7 @@ package org.tests.repository;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
diff --git a/ebean-core/src/test/java/org/tests/saveassociation/TestSaveAssociation.java b/ebean-test/src/test/java/org/tests/saveassociation/TestSaveAssociation.java
similarity index 59%
rename from ebean-core/src/test/java/org/tests/saveassociation/TestSaveAssociation.java
rename to ebean-test/src/test/java/org/tests/saveassociation/TestSaveAssociation.java
index 9724050fc..d7e9fc8ba 100644
--- a/ebean-core/src/test/java/org/tests/saveassociation/TestSaveAssociation.java
+++ b/ebean-test/src/test/java/org/tests/saveassociation/TestSaveAssociation.java
@@ -1,11 +1,12 @@
 package org.tests.saveassociation;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TSDetail;
 import org.tests.model.basic.TSMaster;
-import org.junit.Assert;
-import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestSaveAssociation extends BaseTestCase {
 
@@ -15,18 +16,17 @@ public class TestSaveAssociation extends BaseTestCase {
     TSMaster m0 = new TSMaster();
     m0.setName("master1");
 
-    Ebean.save(m0);
+    DB.save(m0);
 
     m0.addDetail(new TSDetail("master1 detail1"));
     m0.addDetail(new TSDetail("master1 detail2"));
 
-    Ebean.save(m0);
+    DB.save(m0);
 
-    TSMaster m0Check = Ebean.find(TSMaster.class).fetch("details").where().idEq(m0.getId())
+    TSMaster m0Check = DB.find(TSMaster.class).fetch("details").where().idEq(m0.getId())
       .findOne();
 
-    Assert.assertEquals(2, m0Check.getDetails().size());
-
+    assertEquals(2, m0Check.getDetails().size());
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/saveassociation/TestSaveSamePK.java b/ebean-test/src/test/java/org/tests/saveassociation/TestSaveSamePK.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/saveassociation/TestSaveSamePK.java
rename to ebean-test/src/test/java/org/tests/saveassociation/TestSaveSamePK.java
index e2a21562d..4229cbf65 100644
--- a/ebean-core/src/test/java/org/tests/saveassociation/TestSaveSamePK.java
+++ b/ebean-test/src/test/java/org/tests/saveassociation/TestSaveSamePK.java
@@ -2,11 +2,11 @@ package org.tests.saveassociation;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.TSDetail;
 import org.tests.model.basic.TSMaster;
 
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestSaveSamePK extends BaseTestCase {
 
diff --git a/ebean-core/src/test/java/org/tests/singleTableInheritance/TestInheritQuery.java b/ebean-test/src/test/java/org/tests/singleTableInheritance/TestInheritQuery.java
similarity index 52%
rename from ebean-core/src/test/java/org/tests/singleTableInheritance/TestInheritQuery.java
rename to ebean-test/src/test/java/org/tests/singleTableInheritance/TestInheritQuery.java
index 7c7d20a34..061475a40 100644
--- a/ebean-core/src/test/java/org/tests/singleTableInheritance/TestInheritQuery.java
+++ b/ebean-test/src/test/java/org/tests/singleTableInheritance/TestInheritQuery.java
@@ -1,45 +1,41 @@
 package org.tests.singleTableInheritance;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.tests.singleTableInheritance.model.PalletLocation;
-import org.tests.singleTableInheritance.model.PalletLocationExternal;
-import org.tests.singleTableInheritance.model.Warehouse;
-import org.tests.singleTableInheritance.model.Zone;
-import org.tests.singleTableInheritance.model.ZoneExternal;
-import org.tests.singleTableInheritance.model.ZoneInternal;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
+import org.tests.singleTableInheritance.model.*;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestInheritQuery extends BaseTestCase {
 
   @Test
   public void test() {
     ZoneExternal zone = new ZoneExternal();
     zone.setAttribute("ABC");
-    Ebean.save(zone);
+    DB.save(zone);
 
     PalletLocationExternal location = new PalletLocationExternal();
     location.setZone(zone);
     location.setAttribute("123");
-    Ebean.save(location);
+    DB.save(location);
 
     // This line should work too:
-    List<PalletLocation> locations = Ebean.find(PalletLocation.class).where().eq("zone", zone)
+    List<PalletLocation> locations = DB.find(PalletLocation.class).where().eq("zone", zone)
       .findList();
     // List<PalletLocation> locations =
-    // Ebean.find(PalletLocation.class).where().eq("zone.id",
+    // DB.find(PalletLocation.class).where().eq("zone.id",
     // zone.getId()).findList();
 
-    Assert.assertNotNull(locations);
-    Assert.assertEquals(1, locations.size());
+    assertNotNull(locations);
+    assertEquals(1, locations.size());
     PalletLocation rereadLoc = locations.get(0);
-    Assert.assertTrue(rereadLoc instanceof PalletLocation);
+    assertTrue(rereadLoc instanceof PalletLocation);
     Zone rereadZone = rereadLoc.getZone();
-    Assert.assertNotNull(rereadZone);
-    Assert.assertTrue(rereadZone instanceof ZoneExternal);
+    assertNotNull(rereadZone);
+    assertTrue(rereadZone instanceof ZoneExternal);
   }
 
   @SuppressWarnings("unlikely-arg-type")
@@ -47,61 +43,61 @@ public class TestInheritQuery extends BaseTestCase {
   public void testDiscriminator_bug417() {
 
 
-    Ebean.deleteAll(Ebean.find(Warehouse.class).findList());
-    Ebean.deleteAll(Ebean.find(PalletLocation.class).findList());
-    Ebean.deleteAll(Ebean.find(Zone.class).findList());
-    Ebean.deleteAll(Ebean.find(ZoneInternal.class).findList());
-    Ebean.deleteAll(Ebean.find(ZoneInternal.class).findList());
+    DB.deleteAll(DB.find(Warehouse.class).findList());
+    DB.deleteAll(DB.find(PalletLocation.class).findList());
+    DB.deleteAll(DB.find(Zone.class).findList());
+    DB.deleteAll(DB.find(ZoneInternal.class).findList());
+    DB.deleteAll(DB.find(ZoneInternal.class).findList());
 
     ZoneInternal zoneInt = new ZoneInternal();
     zoneInt.setAttribute("some zone 1");
-    Ebean.save(zoneInt);
+    DB.save(zoneInt);
 
     ZoneExternal zoneExt = new ZoneExternal();
     zoneExt.setAttribute("some zone 2");
-    Ebean.save(zoneExt);
+    DB.save(zoneExt);
 
     // queries of Zone and subclasses as root node of query
 
     // query abstract class on attribute (root of heirarchy)
-    List<Zone> zones = Ebean.find(Zone.class).where().startsWith("attribute", "some zone").findList();
+    List<Zone> zones = DB.find(Zone.class).where().startsWith("attribute", "some zone").findList();
     // select t0.type c0, t0.ID c1, t0.attribute c2, t0.attribute c3 from zones t0 where t0.attribute like ? ; --bind(some zone%)
-    Assert.assertEquals(2, zones.size());
-    Assert.assertTrue(zones.contains(zoneInt));
-    Assert.assertTrue(zones.contains(zoneExt));
+    assertEquals(2, zones.size());
+    assertTrue(zones.contains(zoneInt));
+    assertTrue(zones.contains(zoneExt));
 
     // query internal zones only
     // discriminator is in WHERE clause where it belongs
-    List<ZoneInternal> internalZones = Ebean.find(ZoneInternal.class).where().startsWith("attribute", "some zone").findList();
+    List<ZoneInternal> internalZones = DB.find(ZoneInternal.class).where().startsWith("attribute", "some zone").findList();
     // select t0.type c0, t0.ID c1, t0.attribute c2 from zones t0 where t0.type = 'INT'  and t0.attribute like ? ; --bind(some zone%)
-    Assert.assertEquals(1, internalZones.size());
-    Assert.assertTrue(internalZones.contains(zoneInt));
-    Assert.assertFalse(internalZones.contains(zoneExt));
-    Assert.assertTrue(internalZones.get(0) instanceof ZoneInternal);
+    assertEquals(1, internalZones.size());
+    assertTrue(internalZones.contains(zoneInt));
+    assertFalse(internalZones.contains(zoneExt));
+    assertTrue(internalZones.get(0) instanceof ZoneInternal);
 
     // query external zones only
-    List<ZoneExternal> externalZones = Ebean.find(ZoneExternal.class).where().startsWith("attribute", "some zone").findList();
+    List<ZoneExternal> externalZones = DB.find(ZoneExternal.class).where().startsWith("attribute", "some zone").findList();
     // select t0.type c0, t0.ID c1, t0.attribute c2 from zones t0 where t0.type = 'EXT'  and t0.attribute like ? ; --bind(some zone%)
-    Assert.assertEquals(1, externalZones.size());
-    Assert.assertTrue(externalZones.contains(zoneExt));
-    Assert.assertFalse(externalZones.contains(zoneInt));
-    Assert.assertTrue(externalZones.get(0) instanceof ZoneExternal);
+    assertEquals(1, externalZones.size());
+    assertTrue(externalZones.contains(zoneExt));
+    assertFalse(externalZones.contains(zoneInt));
+    assertTrue(externalZones.get(0) instanceof ZoneExternal);
 
     // parents with children of Zones and subclasses
 
     Warehouse wh = new Warehouse();
     wh.setOfficeZone(zoneInt); // many-to-one
     wh.getShippingZones().add(zoneExt); // many-to-many
-    Ebean.save(wh);
+    DB.save(wh);
 
     // JOIN clause, no discriminator
     // parent with many-to-one, doesn't put in discriminator, why not, PK sufficient?
     // eager join
-    Warehouse wh2 = Ebean.find(Warehouse.class, wh.getId());
-    Assert.assertNotNull(wh2);
-    Assert.assertEquals(wh.getId(), wh2.getId());
-    Assert.assertEquals(wh.getOfficeZone(), wh2.getOfficeZone());
-    Assert.assertEquals(wh.getOfficeZone().getAttribute(), wh2.getOfficeZone().getAttribute());
+    Warehouse wh2 = DB.find(Warehouse.class, wh.getId());
+    assertNotNull(wh2);
+    assertEquals(wh.getId(), wh2.getId());
+    assertEquals(wh.getOfficeZone(), wh2.getOfficeZone());
+    assertEquals(wh.getOfficeZone().getAttribute(), wh2.getOfficeZone().getAttribute());
 
     // before the fix, next assertion runs this lazy query:
 
@@ -114,58 +110,58 @@ public class TestInheritQuery extends BaseTestCase {
 
     // this works here because we have at least one shipping zone
 
-    Assert.assertEquals(1, wh2.getShippingZones().size());
-    Assert.assertTrue(wh2.getShippingZones().contains(zoneExt));
+    assertEquals(1, wh2.getShippingZones().size());
+    assertTrue(wh2.getShippingZones().contains(zoneExt));
 
     // set optional concrete to null to set stage for failure
     wh.setOfficeZone(null);
-    Ebean.save(wh);
+    DB.save(wh);
 
     // no discriminator here
-    wh2 = Ebean.find(Warehouse.class)
+    wh2 = DB.find(Warehouse.class)
       .where().eq("id", wh.getId())
       .findOne();
 
-    Assert.assertNotNull(wh2);
+    assertNotNull(wh2);
     // discriminator is used here, should be in join
     // assuming this "manual" fetch is equivalent to autofetch (i.e., autofetch should work the same way)
     // before Daryl's fix
     // select t0.ID c0, t1.type c1, t1.ID c2, t1.attribute c3 from warehouses t0 left join zones t1 on t1.ID = t0.officeZoneId  where t1.type = 'INT'  and t0.ID = ?
     // todo: after Daryl's fix, not sure if this is proper, no discriminator at all, isn't PK/FK sufficient?
     // select t0.ID c0, t1.type c1, t1.ID c2, t1.attribute c3 from warehouses t0 left join zones t1 on t1.ID = t0.officeZoneId  where t0.ID = ? ; --bind(1)
-    wh2 = Ebean.find(Warehouse.class)
+    wh2 = DB.find(Warehouse.class)
       .fetch("officeZone")
       .where().eq("id", wh.getId())
       .findOne();
     // key assertion #1 - fails due to left join with discriminator in WHERE
-    Assert.assertNotNull(wh2);
+    assertNotNull(wh2);
 
     // clear children to set the stage for left join failure
     wh.getShippingZones().clear();
-    Ebean.save(wh);
+    DB.save(wh);
 
-    wh2 = Ebean.find(Warehouse.class, wh.getId());
-    Assert.assertNotNull(wh2);
-    Assert.assertEquals(wh.getId(), wh2.getId());
-    Assert.assertEquals(0, wh.getShippingZones().size());
+    wh2 = DB.find(Warehouse.class, wh.getId());
+    assertNotNull(wh2);
+    assertEquals(wh.getId(), wh2.getId());
+    assertEquals(0, wh.getShippingZones().size());
 
     // query with lazy load of abstract children
-    wh = Ebean.find(Warehouse.class)
+    wh = DB.find(Warehouse.class)
       .where().eq("id", wh.getId())
       .findOne();
-    Assert.assertNotNull(wh);
-    Assert.assertEquals(wh.getId(), wh2.getId());
-    Assert.assertEquals(0, wh.getShippingZones().size());
+    assertNotNull(wh);
+    assertEquals(wh.getId(), wh2.getId());
+    assertEquals(0, wh.getShippingZones().size());
 
     // query with fetch of abstract children
-    wh = Ebean.find(Warehouse.class)
+    wh = DB.find(Warehouse.class)
       .fetch("shippingZones")
       .where().eq("id", wh.getId())
       .findOne();
     // key assertion #2 - fails due to left join with discriminator in WHERE
-    Assert.assertNotNull(wh);
-    Assert.assertEquals(wh.getId(), wh2.getId());
-    Assert.assertEquals(0, wh.getShippingZones().size());
+    assertNotNull(wh);
+    assertEquals(wh.getId(), wh2.getId());
+    assertEquals(0, wh.getShippingZones().size());
 
 
   }
diff --git a/ebean-core/src/test/java/org/tests/singleTableInheritance/model/PalletLocation.java b/ebean-test/src/test/java/org/tests/singleTableInheritance/model/PalletLocation.java
similarity index 61%
rename from ebean-core/src/test/java/org/tests/singleTableInheritance/model/PalletLocation.java
rename to ebean-test/src/test/java/org/tests/singleTableInheritance/model/PalletLocation.java
index 51aafc413..694246b5b 100644
--- a/ebean-core/src/test/java/org/tests/singleTableInheritance/model/PalletLocation.java
+++ b/ebean-test/src/test/java/org/tests/singleTableInheritance/model/PalletLocation.java
@@ -1,15 +1,6 @@
 package org.tests.singleTableInheritance.model;
 
-import javax.persistence.Column;
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
+import javax.persistence.*;
 
 @Entity
 @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
diff --git a/ebean-core/src/test/java/org/tests/singleTableInheritance/model/PalletLocationExternal.java b/ebean-test/src/test/java/org/tests/singleTableInheritance/model/PalletLocationExternal.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/singleTableInheritance/model/PalletLocationExternal.java
rename to ebean-test/src/test/java/org/tests/singleTableInheritance/model/PalletLocationExternal.java
diff --git a/ebean-core/src/test/java/org/tests/singleTableInheritance/model/Warehouse.java b/ebean-test/src/test/java/org/tests/singleTableInheritance/model/Warehouse.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/singleTableInheritance/model/Warehouse.java
rename to ebean-test/src/test/java/org/tests/singleTableInheritance/model/Warehouse.java
index 58b935c49..b79e59950 100644
--- a/ebean-core/src/test/java/org/tests/singleTableInheritance/model/Warehouse.java
+++ b/ebean-test/src/test/java/org/tests/singleTableInheritance/model/Warehouse.java
@@ -1,14 +1,6 @@
 package org.tests.singleTableInheritance.model;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.Set;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/singleTableInheritance/model/Zone.java b/ebean-test/src/test/java/org/tests/singleTableInheritance/model/Zone.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/singleTableInheritance/model/Zone.java
rename to ebean-test/src/test/java/org/tests/singleTableInheritance/model/Zone.java
index 0c27f7742..f0f820ded 100644
--- a/ebean-core/src/test/java/org/tests/singleTableInheritance/model/Zone.java
+++ b/ebean-test/src/test/java/org/tests/singleTableInheritance/model/Zone.java
@@ -1,13 +1,6 @@
 package org.tests.singleTableInheritance.model;
 
-import javax.persistence.Column;
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.Table;
+import javax.persistence.*;
 
 @Entity
 @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
diff --git a/ebean-core/src/test/java/org/tests/singleTableInheritance/model/ZoneExternal.java b/ebean-test/src/test/java/org/tests/singleTableInheritance/model/ZoneExternal.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/singleTableInheritance/model/ZoneExternal.java
rename to ebean-test/src/test/java/org/tests/singleTableInheritance/model/ZoneExternal.java
diff --git a/ebean-core/src/test/java/org/tests/singleTableInheritance/model/ZoneInternal.java b/ebean-test/src/test/java/org/tests/singleTableInheritance/model/ZoneInternal.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/singleTableInheritance/model/ZoneInternal.java
rename to ebean-test/src/test/java/org/tests/singleTableInheritance/model/ZoneInternal.java
diff --git a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteBasic.java b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteBasic.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteBasic.java
rename to ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteBasic.java
index 3364417b9..4d5fd67af 100644
--- a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteBasic.java
+++ b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteBasic.java
@@ -1,13 +1,8 @@
 package org.tests.softdelete;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.Query;
-import io.ebean.SqlQuery;
-import io.ebean.SqlRow;
-import io.ebean.Transaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.*;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.softdelete.EBasicNoSDChild;
 import org.tests.model.softdelete.EBasicSDChild;
 import org.tests.model.softdelete.EBasicSoftDelete;
@@ -36,11 +31,11 @@ public class TestSoftDeleteBasic extends BaseTestCase {
     assertThat(bean.getVersion()).isEqualTo(1);
     assertThat(bean.getChildren().get(0).getVersion()).isEqualTo(1);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.delete(bean);
 
-//    List<String> loggedSql = LoggedSqlCollector.stop();
+//    List<String> loggedSql = LoggedSql.stop();
 //
 //    assertEquals(new Long(2), bean.getVersion());
 //    assertEquals(new Long(2), bean.getChildren().get(0).getVersion()); // Fails with 1
@@ -65,20 +60,20 @@ public class TestSoftDeleteBasic extends BaseTestCase {
     bean.setName("findSingleAttribute");
     DB.save(bean);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     final String name0 = DB.find(EBasicSoftDelete.class)
       .select("name")
       .where().eq("name", "findSingleAttribute")
       .findSingleAttribute();
 
-    List<String> sql0 = LoggedSqlCollector.current();
+    List<String> sql0 = LoggedSql.collect();
     assertThat(sql0.get(0)).contains("where t0.name = ? and t0.deleted =");
     assertThat(name0).isEqualTo("findSingleAttribute");
 
     // now soft delete the bean
     DB.delete(bean);
-    List<String> sqlUpdate = LoggedSqlCollector.current();
+    List<String> sqlUpdate = LoggedSql.collect();
     assertThat(sqlUpdate.get(0)).contains("update ebasic_sdchild set");
 
     // use setIncludeSoftDeletes
@@ -88,7 +83,7 @@ public class TestSoftDeleteBasic extends BaseTestCase {
       .setIncludeSoftDeletes()
       .findSingleAttribute();
 
-    List<String> sql1 = LoggedSqlCollector.current();
+    List<String> sql1 = LoggedSql.collect();
     assertThat(sql1.get(0)).doesNotContain(" and t0.deleted =");
     assertThat(name1).isEqualTo("findSingleAttribute");
 
@@ -99,7 +94,7 @@ public class TestSoftDeleteBasic extends BaseTestCase {
       .where().eq("name", "findSingleAttribute")
       .findSingleAttribute();
 
-    List<String> sql2 = LoggedSqlCollector.stop();
+    List<String> sql2 = LoggedSql.stop();
     assertThat(sql2.get(0)).contains(" and t0.deleted =");
     assertThat(name2).isNull();
   }
@@ -116,7 +111,7 @@ public class TestSoftDeleteBasic extends BaseTestCase {
     DB.save(bean);
     DB.delete(bean.getChildren().get(0));
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     List<Object> ids = DB.find(EBasicSDChild.class).where().eq("owner", bean).findIds();
     assertThat(ids).hasSize(2);
@@ -124,7 +119,7 @@ public class TestSoftDeleteBasic extends BaseTestCase {
     List<EBasicSDChild> beans = DB.find(EBasicSDChild.class).where().eq("owner", bean).findList();
     assertThat(beans).hasSize(2);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("from ebasic_sdchild t0 where t0.owner_id = ? and t0.deleted = ");
@@ -241,7 +236,7 @@ public class TestSoftDeleteBasic extends BaseTestCase {
                                          .query();
 
     List<EBasicSoftDelete> list = query.findList();
-    if (isMySql() || isMariaDB()) {
+    if (isMySql() || isMariaDB() || isSqlServer()) {
       assertSql(query).contains("t0.deleted = 0");
       assertSql(query).contains("u1.deleted = 0");
     } else {
@@ -277,7 +272,7 @@ public class TestSoftDeleteBasic extends BaseTestCase {
 
     List<EBasicNoSDChild> list = query.findList();
     // Make sure that query includes that the child mustn't've been deleted
-    if (isMySql() || isMariaDB()) {
+    if (isMySql() || isMariaDB() || isSqlServer()) {
       assertSql(query).contains("u1.deleted = 0");
       assertSql(query).contains("u2.deleted = 0");
     } else {
@@ -336,10 +331,10 @@ public class TestSoftDeleteBasic extends BaseTestCase {
 
     // -- test .findCount()
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     int rowCountAfter = DB.find(EBasicSoftDelete.class).findCount();
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).contains("where t0.deleted =");
 
@@ -347,11 +342,11 @@ public class TestSoftDeleteBasic extends BaseTestCase {
 
     // -- test includeSoftDeletes().findCount()
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     int rowCountFull = DB.find(EBasicSoftDelete.class).setIncludeSoftDeletes().findCount();
     assertThat(rowCountFull).isGreaterThan(rowCountAfter);
 
-    loggedSql = LoggedSqlCollector.stop();
+    loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(1);
     assertThat(loggedSql.get(0)).doesNotContain("where coalesce(t0.deleted,false)=false");
   }
@@ -369,11 +364,11 @@ public class TestSoftDeleteBasic extends BaseTestCase {
       .setId(bean.getId())
       .findOne();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.delete(partial);
 
     // check lazy loading isn't invoked (deleted set to true without invoking lazy loading)
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertThat(loggedSql).hasSize(2);
     assertThat(loggedSql.get(0)).contains("update ebasic_sdchild set deleted=");
     assertThat(loggedSql.get(1)).contains("update ebasic_soft_delete set deleted=? where id=?");
@@ -392,11 +387,11 @@ public class TestSoftDeleteBasic extends BaseTestCase {
 
     DB.save(bean);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     DB.delete(bean);
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     // The children without SoftDelete are left as is (so no third statement)
     assertThat(loggedSql).hasSize(2);
@@ -426,7 +421,7 @@ public class TestSoftDeleteBasic extends BaseTestCase {
 
     DB.delete(bean.getChildren().get(1));
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Query<EBasicSoftDelete> query1 =
       DB.find(EBasicSoftDelete.class)
diff --git a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteBook.java b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteBook.java
similarity index 73%
rename from ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteBook.java
rename to ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteBook.java
index 68c2c7f69..992ada21a 100644
--- a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteBook.java
+++ b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteBook.java
@@ -1,11 +1,11 @@
 package org.tests.softdelete;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
+import org.junit.jupiter.api.Test;
 import org.tests.model.softdelete.ESoftDelBook;
 import org.tests.model.softdelete.ESoftDelUser;
-import org.junit.Test;
 
 import java.util.Arrays;
 
@@ -18,28 +18,28 @@ public class TestSoftDeleteBook extends BaseTestCase {
 
     // Create users
     ESoftDelUser user1 = new ESoftDelUser("user1");
-    Ebean.save(user1);
+    DB.save(user1);
 
     ESoftDelUser user2 = new ESoftDelUser("user2");
-    Ebean.save(user2);
+    DB.save(user2);
 
     ESoftDelUser user3 = new ESoftDelUser("user3");
-    Ebean.save(user3);
+    DB.save(user3);
 
     // Create books
     ESoftDelBook book1 = new ESoftDelBook("book1");
     book1.setLendBy(user1);
     book1.setLendBys(Arrays.asList(user2, user3));
-    Ebean.save(book1);
+    DB.save(book1);
 
     ESoftDelBook book2 = new ESoftDelBook("book2");
     book2.setLendBy(user2);
     book2.setLendBys(Arrays.asList(user1, user3));
-    Ebean.save(book2);
+    DB.save(book2);
 
     // check if everything is stored correctly in DB
-    book1 = Ebean.find(ESoftDelBook.class).where().eq("bookTitle", "book1").findOne();
-    book2 = Ebean.find(ESoftDelBook.class).where().eq("bookTitle", "book2").findOne();
+    book1 = DB.find(ESoftDelBook.class).where().eq("bookTitle", "book1").findOne();
+    book2 = DB.find(ESoftDelBook.class).where().eq("bookTitle", "book2").findOne();
 
     assertThat(book1.getLendBys().size()).isEqualTo(2);
     assertThat(book2.getLendBys().size()).isEqualTo(2);
@@ -47,11 +47,11 @@ public class TestSoftDeleteBook extends BaseTestCase {
     assertThat(book2.getLendBy().getUserName()).isEqualTo("user2");
 
     // delete user 1
-    Ebean.delete(user1);
+    DB.delete(user1);
 
     // check if everything is still stored correctly in DB (softdeletes included)
-    book1 = Ebean.find(ESoftDelBook.class).where().eq("bookTitle", "book1").setIncludeSoftDeletes().findOne();
-    book2 = Ebean.find(ESoftDelBook.class).where().eq("bookTitle", "book2").setIncludeSoftDeletes().findOne();
+    book1 = DB.find(ESoftDelBook.class).where().eq("bookTitle", "book1").setIncludeSoftDeletes().findOne();
+    book2 = DB.find(ESoftDelBook.class).where().eq("bookTitle", "book2").setIncludeSoftDeletes().findOne();
 
     assertThat(book1.getLendBys().size()).isEqualTo(2);
     assertThat(book2.getLendBys().size()).isEqualTo(2);
@@ -60,8 +60,8 @@ public class TestSoftDeleteBook extends BaseTestCase {
 
 
     // check without softdeletes included
-    book1 = Ebean.find(ESoftDelBook.class).where().eq("bookTitle", "book1").findOne();
-    book2 = Ebean.find(ESoftDelBook.class).where().eq("bookTitle", "book2").findOne();
+    book1 = DB.find(ESoftDelBook.class).where().eq("bookTitle", "book1").findOne();
+    book2 = DB.find(ESoftDelBook.class).where().eq("bookTitle", "book2").findOne();
 
     assertThat(book1.getLendBys().size()).isEqualTo(2); // user2 & user3
     assertThat(book2.getLendBys().size()).isEqualTo(1); // user1 (deleted) & user3
@@ -83,21 +83,21 @@ public class TestSoftDeleteBook extends BaseTestCase {
 
     // Create users
     ESoftDelUser user1 = new ESoftDelUser("user1");
-    Ebean.save(user1);
+    DB.save(user1);
 
     ESoftDelUser user2 = new ESoftDelUser("user2");
-    Ebean.save(user2);
+    DB.save(user2);
 
     // Create books
     ESoftDelBook book1 = new ESoftDelBook("book3");
     book1.setLendBy(user1);
     book1.setLendBys(Arrays.asList(user1, user2));
-    Ebean.save(book1);
+    DB.save(book1);
 
-    Ebean.delete(user1);
-    Ebean.delete(user2);
+    DB.delete(user1);
+    DB.delete(user2);
 
-    Query<ESoftDelBook> query = Ebean.find(ESoftDelBook.class)
+    Query<ESoftDelBook> query = DB.find(ESoftDelBook.class)
       .setId(book1.getId())
       .fetch("lendBys");
 
diff --git a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteManyToMany.java b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteManyToMany.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteManyToMany.java
rename to ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteManyToMany.java
index 918445e1e..45d44dd82 100644
--- a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteManyToMany.java
+++ b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteManyToMany.java
@@ -1,11 +1,11 @@
 package org.tests.softdelete;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.softdelete.ESoftDelRole;
 import org.tests.model.softdelete.ESoftDelUser;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
 
 import java.util.List;
 
@@ -19,20 +19,20 @@ public class TestSoftDeleteManyToMany extends BaseTestCase {
     ESoftDelRole role1 = new ESoftDelRole("role1");
     ESoftDelRole role2 = new ESoftDelRole("role2");
 
-    Ebean.save(role1);
-    Ebean.save(role2);
+    DB.save(role1);
+    DB.save(role2);
 
     ESoftDelUser user1 = new ESoftDelUser("user1");
     user1.getRoles().add(role1);
     user1.getRoles().add(role2);
 
-    Ebean.save(user1);
+    DB.save(user1);
 
 
-    LoggedSqlCollector.start();
-    Ebean.delete(user1);
+    LoggedSql.start();
+    DB.delete(user1);
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     // No Delete from the relationship table
     assertThat(loggedSql).hasSize(1);
diff --git a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteOptionalRelationship.java b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteOptionalRelationship.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteOptionalRelationship.java
rename to ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteOptionalRelationship.java
index b4e320b21..f5650673b 100644
--- a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteOptionalRelationship.java
+++ b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteOptionalRelationship.java
@@ -2,11 +2,10 @@ package org.tests.softdelete;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.tests.model.softdelete.ESoftDelMid;
 import io.ebean.Finder;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
+import org.tests.model.softdelete.ESoftDelMid;
 import org.tests.model.softdelete.ESoftDelY;
 import org.tests.model.softdelete.ESoftDelZ;
 
@@ -21,9 +20,9 @@ public class TestSoftDeleteOptionalRelationship extends BaseTestCase {
   public void testFindWhenNullRelationship() {
 
     ESoftDelMid mid1 = new ESoftDelMid(null, "mid1");
-    Ebean.save(mid1);
+    DB.save(mid1);
 
-    ESoftDelMid bean = Ebean.find(ESoftDelMid.class)
+    ESoftDelMid bean = DB.find(ESoftDelMid.class)
       .setId(mid1.getId())
       .fetch("top")
       .findOne();
@@ -46,7 +45,7 @@ public class TestSoftDeleteOptionalRelationship extends BaseTestCase {
       DB.save(y);
     }
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Finder<Long, ESoftDelY> finder = new Finder<>(ESoftDelY.class);
     ESoftDelY bean = finder
@@ -58,9 +57,13 @@ public class TestSoftDeleteOptionalRelationship extends BaseTestCase {
 
     assertThat(bean).isNotNull();
 
-    final List<String> sql = LoggedSqlCollector.stop();
+    final List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
-    assertThat(sql.get(0)).contains("left join esoft_del_z t1 on t1.id = t0.organization_id and t1.deleted = false where");
+    if (isSqlServer() || isMySql() || isMariaDB()) {
+      assertThat(sql.get(0)).contains("left join esoft_del_z t1 on t1.id = t0.organization_id and t1.deleted = 0 where");
+    } else {
+      assertThat(sql.get(0)).contains("left join esoft_del_z t1 on t1.id = t0.organization_id and t1.deleted = false where");
+    }
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteOtoCascade.java b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteOtoCascade.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteOtoCascade.java
rename to ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteOtoCascade.java
index d5eeefedc..d150d9712 100644
--- a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteOtoCascade.java
+++ b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteOtoCascade.java
@@ -1,9 +1,9 @@
 package org.tests.softdelete;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.DB;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.softdelete.ESoftDelOneA;
 import org.tests.model.softdelete.ESoftDelOneB;
 
@@ -22,15 +22,15 @@ public class TestSoftDeleteOtoCascade extends BaseTestCase {
     a.setOneb(b);
     b.setOnea(a);
 
-    Ebean.save(a);
+    DB.save(a);
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // delete doesn't cascade to ESoftDelOneB as this is a
     // soft delete and ESoftDelOneB doesn't have soft delete flag
-    Ebean.delete(a);
+    DB.delete(a);
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(1);
     assertSql(sql.get(0)).contains("update esoft_del_one_a set deleted=?, version=? where id=? and version=?");
 
diff --git a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteStatelessUpdate.java b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteStatelessUpdate.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteStatelessUpdate.java
rename to ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteStatelessUpdate.java
index ee8c1590a..a8d548ebe 100644
--- a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteStatelessUpdate.java
+++ b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteStatelessUpdate.java
@@ -2,8 +2,8 @@ package org.tests.softdelete;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebeantest.LoggedSql;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.softdelete.EsdDetail;
 import org.tests.model.softdelete.EsdMaster;
 
diff --git a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteTop.java b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteTop.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteTop.java
rename to ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteTop.java
index 07388a367..c34b75ef8 100644
--- a/ebean-core/src/test/java/org/tests/softdelete/TestSoftDeleteTop.java
+++ b/ebean-test/src/test/java/org/tests/softdelete/TestSoftDeleteTop.java
@@ -1,10 +1,10 @@
 package org.tests.softdelete;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Query;
 import io.ebean.Transaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.softdelete.ESoftDelMid;
 import org.tests.model.softdelete.ESoftDelTop;
 import org.tests.model.softdelete.ESoftDelUp;
@@ -20,10 +20,10 @@ public class TestSoftDeleteTop extends BaseTestCase {
   public void testDeletePermanent() {
 
     ESoftDelUp up1 = new ESoftDelUp("up1");
-    Ebean.save(up1);
+    DB.save(up1);
 
-    Ebean.delete(up1);
-    Ebean.deletePermanent(up1);
+    DB.delete(up1);
+    DB.deletePermanent(up1);
   }
 
 
@@ -31,15 +31,15 @@ public class TestSoftDeleteTop extends BaseTestCase {
   public void testSoftDeleteJdbcBatch() {
 
     ESoftDelUp up1 = new ESoftDelUp("upBatch1");
-    Ebean.save(up1);
+    DB.save(up1);
     ESoftDelUp up2 = new ESoftDelUp("upBatch2");
-    Ebean.save(up2);
+    DB.save(up2);
 
-    Transaction transaction = Ebean.beginTransaction();
+    Transaction transaction = DB.beginTransaction();
     try {
       transaction.setBatchMode(true);
-      Ebean.delete(up1);
-      Ebean.delete(up2);
+      DB.delete(up1);
+      DB.delete(up2);
       transaction.commit();
     } finally {
       transaction.end();
@@ -49,7 +49,7 @@ public class TestSoftDeleteTop extends BaseTestCase {
     list.add(up1);
     list.add(up2);
 
-    Ebean.deleteAllPermanent(list);
+    DB.deleteAllPermanent(list);
   }
 
   @Test
@@ -63,9 +63,9 @@ public class TestSoftDeleteTop extends BaseTestCase {
     list.add(up2);
 
     // by default uses JDBC for the 'all' methods
-    Ebean.saveAll(list);
-    Ebean.deleteAll(list);
-    Ebean.deleteAllPermanent(list);
+    DB.saveAll(list);
+    DB.deleteAll(list);
+    DB.deleteAllPermanent(list);
 
   }
 
@@ -84,11 +84,11 @@ public class TestSoftDeleteTop extends BaseTestCase {
     mid2.addDown("down3");
     mid2.addDown("down4");
 
-    Ebean.save(top1);
+    DB.save(top1);
 
-    Ebean.delete(top1);
+    DB.delete(top1);
 
-    Ebean.deletePermanent(top1);
+    DB.deletePermanent(top1);
   }
 
   @Test
@@ -98,9 +98,9 @@ public class TestSoftDeleteTop extends BaseTestCase {
     top1.addMids("mid1");
     top1.addMids("mid2");
 
-    Ebean.save(top1);
+    DB.save(top1);
 
-    Query<ESoftDelTop> query = Ebean.find(ESoftDelTop.class)
+    Query<ESoftDelTop> query = DB.find(ESoftDelTop.class)
       .where().isEmpty("mids")
       .query();
 
diff --git a/ebean-core/src/test/java/org/tests/sp/TestManyToManySaveTwice.java b/ebean-test/src/test/java/org/tests/sp/TestManyToManySaveTwice.java
similarity index 87%
rename from ebean-core/src/test/java/org/tests/sp/TestManyToManySaveTwice.java
rename to ebean-test/src/test/java/org/tests/sp/TestManyToManySaveTwice.java
index a505a5d54..17a211de7 100644
--- a/ebean-core/src/test/java/org/tests/sp/TestManyToManySaveTwice.java
+++ b/ebean-test/src/test/java/org/tests/sp/TestManyToManySaveTwice.java
@@ -2,9 +2,8 @@ package org.tests.sp;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.Transaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.sp.model.car.Car;
 import org.tests.sp.model.car.Door;
 import org.tests.sp.model.car.Wheel;
@@ -13,8 +12,8 @@ import java.util.LinkedList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestManyToManySaveTwice extends BaseTestCase {
 
@@ -57,8 +56,8 @@ public class TestManyToManySaveTwice extends BaseTestCase {
       transaction.commit();
     }
 
-    c0 = Ebean.find(Car.class, c0.getId());
-    c1 = Ebean.find(Car.class, c1.getId());
+    c0 = DB.find(Car.class, c0.getId());
+    c1 = DB.find(Car.class, c1.getId());
 
     assertThat(c0.getWheels()).hasSize(2);
     assertThat(c0.getDoors()).hasSize(1);
@@ -113,10 +112,10 @@ public class TestManyToManySaveTwice extends BaseTestCase {
 
     DB.save(c); // NOTE 2ND SAVE
 
-    List<Car> allCars = Ebean.find(Car.class).findList();
+    List<Car> allCars = DB.find(Car.class).findList();
     assertEquals(1, allCars.size());
 
-    List<Wheel> allWheels = Ebean.find(Wheel.class).findList();
+    List<Wheel> allWheels = DB.find(Wheel.class).findList();
     assertEquals(4, allWheels.size());
   }
 
diff --git a/ebean-core/src/test/java/org/tests/sp/model/IdEntity.java b/ebean-test/src/test/java/org/tests/sp/model/IdEntity.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/sp/model/IdEntity.java
rename to ebean-test/src/test/java/org/tests/sp/model/IdEntity.java
index c6e8d68ca..a45108d28 100644
--- a/ebean-core/src/test/java/org/tests/sp/model/IdEntity.java
+++ b/ebean-test/src/test/java/org/tests/sp/model/IdEntity.java
@@ -1,13 +1,8 @@
 package org.tests.sp.model;
 
+import javax.persistence.*;
 import java.io.Serializable;
 
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.MappedSuperclass;
-import javax.persistence.Version;
-
 @MappedSuperclass
 public abstract class IdEntity implements Serializable {
   private static final long serialVersionUID = 7804145008732783678L;
diff --git a/ebean-core/src/test/java/org/tests/sp/model/car/Car.java b/ebean-test/src/test/java/org/tests/sp/model/car/Car.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/sp/model/car/Car.java
rename to ebean-test/src/test/java/org/tests/sp/model/car/Car.java
index d742444d2..415dcecba 100644
--- a/ebean-core/src/test/java/org/tests/sp/model/car/Car.java
+++ b/ebean-test/src/test/java/org/tests/sp/model/car/Car.java
@@ -2,12 +2,7 @@ package org.tests.sp.model.car;
 
 import org.tests.sp.model.IdEntity;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
-import javax.persistence.Table;
+import javax.persistence.*;
 import java.util.List;
 
 @Entity
diff --git a/ebean-core/src/test/java/org/tests/sp/model/car/Door.java b/ebean-test/src/test/java/org/tests/sp/model/car/Door.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/sp/model/car/Door.java
rename to ebean-test/src/test/java/org/tests/sp/model/car/Door.java
diff --git a/ebean-core/src/test/java/org/tests/sp/model/car/Wheel.java b/ebean-test/src/test/java/org/tests/sp/model/car/Wheel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/sp/model/car/Wheel.java
rename to ebean-test/src/test/java/org/tests/sp/model/car/Wheel.java
diff --git a/ebean-core/src/test/java/org/tests/test/TestInheritWithMany.java b/ebean-test/src/test/java/org/tests/test/TestInheritWithMany.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/test/TestInheritWithMany.java
rename to ebean-test/src/test/java/org/tests/test/TestInheritWithMany.java
index 670080584..7b510e858 100644
--- a/ebean-core/src/test/java/org/tests/test/TestInheritWithMany.java
+++ b/ebean-test/src/test/java/org/tests/test/TestInheritWithMany.java
@@ -1,20 +1,21 @@
 package org.tests.test;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.InheritInfo;
+import org.junit.jupiter.api.Test;
 import org.tests.model.inheritmany.IMRelated;
 import org.tests.model.inheritmany.IMRoot;
 import org.tests.model.inheritmany.IMRootOne;
 import org.tests.model.inheritmany.IMRootTwo;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 
 public class TestInheritWithMany extends BaseTestCase {
 
@@ -22,13 +23,13 @@ public class TestInheritWithMany extends BaseTestCase {
   @Test
   public void test() {
 
-    EbeanServer server = Ebean.getServer(null);
-    Assert.assertNotNull(server);
+    Database server = DB.getDefault();
+    assertNotNull(server);
 
     SpiEbeanServer spiServer = (SpiEbeanServer) server;
-    BeanDescriptor<IMRoot> beanDescriptor = spiServer.getBeanDescriptor(IMRoot.class);
-    InheritInfo inheritInfo = beanDescriptor.getInheritInfo();
-    Assert.assertNotNull(inheritInfo);
+    BeanDescriptor<IMRoot> beanDescriptor = spiServer.descriptor(IMRoot.class);
+    InheritInfo inheritInfo = beanDescriptor.inheritInfo();
+    assertNotNull(inheritInfo);
 
 
     IMRootOne one = new IMRootOne();
@@ -63,7 +64,7 @@ public class TestInheritWithMany extends BaseTestCase {
     relate.setName(string);
     relate.setOwner(owner);
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
     server.save(relate);
   }
 
diff --git a/ebean-core/src/test/java/org/tests/text/csv/TestCsvReader.java b/ebean-test/src/test/java/org/tests/text/csv/TestCsvReader.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/text/csv/TestCsvReader.java
rename to ebean-test/src/test/java/org/tests/text/csv/TestCsvReader.java
index 57ac6755f..313f5017c 100644
--- a/ebean-core/src/test/java/org/tests/text/csv/TestCsvReader.java
+++ b/ebean-test/src/test/java/org/tests/text/csv/TestCsvReader.java
@@ -3,7 +3,7 @@ package org.tests.text.csv;
 import io.ebean.DB;
 import io.ebean.TransactionalTestCase;
 import io.ebean.text.csv.CsvReader;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
diff --git a/ebean-core/src/test/java/org/tests/text/csv/TestCsvReaderWithCallback.java b/ebean-test/src/test/java/org/tests/text/csv/TestCsvReaderWithCallback.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/text/csv/TestCsvReaderWithCallback.java
rename to ebean-test/src/test/java/org/tests/text/csv/TestCsvReaderWithCallback.java
index 76127c8cb..ef6bfd8c7 100644
--- a/ebean-core/src/test/java/org/tests/text/csv/TestCsvReaderWithCallback.java
+++ b/ebean-test/src/test/java/org/tests/text/csv/TestCsvReaderWithCallback.java
@@ -4,7 +4,7 @@ import io.ebean.DB;
 import io.ebean.TransactionalTestCase;
 import io.ebean.text.csv.CsvReader;
 import io.ebean.text.csv.DefaultCsvCallback;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import java.io.File;
diff --git a/ebean-core/src/test/java/org/tests/text/csv/TestTimeStringParser.java b/ebean-test/src/test/java/org/tests/text/csv/TestTimeStringParser.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/text/csv/TestTimeStringParser.java
rename to ebean-test/src/test/java/org/tests/text/csv/TestTimeStringParser.java
index fac5e5095..3aea61ade 100644
--- a/ebean-core/src/test/java/org/tests/text/csv/TestTimeStringParser.java
+++ b/ebean-test/src/test/java/org/tests/text/csv/TestTimeStringParser.java
@@ -2,21 +2,22 @@ package org.tests.text.csv;
 
 import io.ebean.BaseTestCase;
 import io.ebean.text.TimeStringParser;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Time;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestTimeStringParser extends BaseTestCase {
 
   @Test
   public void testSimple() {
 
     Time t = (Time) TimeStringParser.get().parse("12:00");
-    Assert.assertNotNull(t);
+    assertNotNull(t);
 
     t = (Time) TimeStringParser.get().parse("12:00:12");
-    Assert.assertNotNull(t);
+    assertNotNull(t);
 
     expectError("12");
     expectError("12:");
@@ -29,9 +30,9 @@ public class TestTimeStringParser extends BaseTestCase {
   private void expectError(String value) {
     try {
       TimeStringParser.get().parse(value);
-      Assert.assertTrue(false);
+      fail();
     } catch (IllegalArgumentException e) {
-      Assert.assertTrue(true);
+      assertTrue(true);
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestJsonBeanDescriptorParse.java b/ebean-test/src/test/java/org/tests/text/json/TestJsonBeanDescriptorParse.java
similarity index 56%
rename from ebean-core/src/test/java/org/tests/text/json/TestJsonBeanDescriptorParse.java
rename to ebean-test/src/test/java/org/tests/text/json/TestJsonBeanDescriptorParse.java
index eaf1825fc..ddd05f05c 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestJsonBeanDescriptorParse.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestJsonBeanDescriptorParse.java
@@ -3,28 +3,28 @@ package org.tests.text.json;
 import com.fasterxml.jackson.core.JsonParser;
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.json.SpiJsonReader;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.text.json.ReadJson;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import java.io.IOException;
 import java.io.StringReader;
 import java.util.Set;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestJsonBeanDescriptorParse extends BaseTestCase {
 
   @Test
   public void test() throws IOException {
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
 
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
-
-    BeanDescriptor<Customer> descriptor = server.getBeanDescriptor(Customer.class);
-
+    BeanDescriptor<Customer> descriptor = server.descriptor(Customer.class);
 
     StringReader reader = new StringReader("{\"id\":123,\"name\":\"Hello rob\"}");
     JsonParser parser = server.json().createParser(reader);
@@ -33,16 +33,15 @@ public class TestJsonBeanDescriptorParse extends BaseTestCase {
 
     Customer customer = descriptor.jsonRead(readJson, null);
 
-    Assert.assertEquals(Integer.valueOf(123), customer.getId());
-    Assert.assertEquals("Hello rob", customer.getName());
+    assertEquals(Integer.valueOf(123), customer.getId());
+    assertEquals("Hello rob", customer.getName());
 
-    BeanState beanState = Ebean.getBeanState(customer);
-    Set<String> loadedProps = beanState.getLoadedProps();
-
-    Assert.assertEquals(2, loadedProps.size());
-    Assert.assertTrue(loadedProps.contains("id"));
-    Assert.assertTrue(loadedProps.contains("name"));
+    BeanState beanState = DB.beanState(customer);
+    Set<String> loadedProps = beanState.loadedProps();
 
+    assertEquals(2, loadedProps.size());
+    assertTrue(loadedProps.contains("id"));
+    assertTrue(loadedProps.contains("name"));
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestJsonBeanWithTimeZone.java b/ebean-test/src/test/java/org/tests/text/json/TestJsonBeanWithTimeZone.java
similarity index 60%
rename from ebean-core/src/test/java/org/tests/text/json/TestJsonBeanWithTimeZone.java
rename to ebean-test/src/test/java/org/tests/text/json/TestJsonBeanWithTimeZone.java
index 63630140f..f07c31d65 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestJsonBeanWithTimeZone.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestJsonBeanWithTimeZone.java
@@ -1,44 +1,42 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.BeanWithTimeZone;
-import org.junit.Assert;
-import org.junit.Test;
 
-import java.io.IOException;
 import java.util.TimeZone;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestJsonBeanWithTimeZone extends BaseTestCase {
 
   @Test
-  public void testSimple() throws IOException {
-
+  public void testSimple() {
     TimeZone defaultTimeZone = TimeZone.getDefault();
 
     TimeZone.getAvailableIDs(defaultTimeZone.getRawOffset());
 
     String id = defaultTimeZone.getID();
     TimeZone timeZone = TimeZone.getTimeZone(id);
-    Assert.assertEquals(defaultTimeZone, timeZone);
+    assertEquals(defaultTimeZone, timeZone);
 
     BeanWithTimeZone bean = new BeanWithTimeZone();
     bean.setName("foo");
     bean.setTimezone(TimeZone.getDefault());
 
-    JsonContext jsonContext = Ebean.json();
+    JsonContext jsonContext = DB.json();
     String jsonContent = jsonContext.toJson(bean);
 
     BeanWithTimeZone bean2 = jsonContext.toBean(BeanWithTimeZone.class, jsonContent);
 
-    Assert.assertEquals(bean.getTimezone(), bean2.getTimezone());
+    assertEquals(bean.getTimezone(), bean2.getTimezone());
 
-    Ebean.save(bean);
-    BeanWithTimeZone bean3 = Ebean.find(BeanWithTimeZone.class, bean.getId());
-
-    Assert.assertEquals(bean.getTimezone(), bean3.getTimezone());
+    DB.save(bean);
+    BeanWithTimeZone bean3 = DB.find(BeanWithTimeZone.class, bean.getId());
 
+    assertEquals(bean.getTimezone(), bean3.getTimezone());
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestJsonInheritanceDiscriminator.java b/ebean-test/src/test/java/org/tests/text/json/TestJsonInheritanceDiscriminator.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/text/json/TestJsonInheritanceDiscriminator.java
rename to ebean-test/src/test/java/org/tests/text/json/TestJsonInheritanceDiscriminator.java
index 75402e4d9..19ac15925 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestJsonInheritanceDiscriminator.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestJsonInheritanceDiscriminator.java
@@ -1,9 +1,9 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Animal;
 import org.tests.model.basic.Cat;
 import org.tests.model.basic.Dog;
@@ -11,7 +11,7 @@ import org.tests.model.basic.Dog;
 import java.sql.Date;
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonInheritanceDiscriminator extends BaseTestCase {
 
@@ -21,9 +21,9 @@ public class TestJsonInheritanceDiscriminator extends BaseTestCase {
     Cat cat = new Cat();
     cat.setName("Gemma");
 
-    Ebean.save(cat);
+    DB.save(cat);
 
-    JsonContext json = Ebean.json();
+    JsonContext json = DB.json();
     String jsonContent = json.toJson(cat);
 
     Cat cat2 = json.toBean(Cat.class, jsonContent);
@@ -44,9 +44,9 @@ public class TestJsonInheritanceDiscriminator extends BaseTestCase {
     dog.setRegistrationNumber("ABC123");
     dog.setDateOfBirth(new Date(System.currentTimeMillis()));
 
-    Ebean.save(dog);
+    DB.save(dog);
 
-    List<Animal> animals = Ebean.find(Animal.class).findList();
+    List<Animal> animals = DB.find(Animal.class).findList();
 
     String listJson = json.toJson(animals);
 
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestJsonMap.java b/ebean-test/src/test/java/org/tests/text/json/TestJsonMap.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/text/json/TestJsonMap.java
rename to ebean-test/src/test/java/org/tests/text/json/TestJsonMap.java
index 4237d5fd6..c955939d5 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestJsonMap.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestJsonMap.java
@@ -1,19 +1,19 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.PathProperties;
 import io.ebean.text.json.JsonContext;
 import io.ebean.text.json.JsonWriteOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestJsonMap extends BaseTestCase {
 
@@ -22,9 +22,9 @@ public class TestJsonMap extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> customers = Ebean.find(Customer.class).findList();
+    List<Customer> customers = DB.find(Customer.class).findList();
 
-    JsonContext jsonContext = Ebean.json();
+    JsonContext jsonContext = DB.json();
 
     JsonWriteOptions jsonWriteOptions = JsonWriteOptions.parsePath("(id,status,name)");
     String jsonString = jsonContext.toJson(customers, jsonWriteOptions);
@@ -41,9 +41,9 @@ public class TestJsonMap extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    Map<String, Customer> map = Ebean.find(Customer.class).findMap();
+    Map<String, Customer> map = DB.find(Customer.class).findMap();
 
-    JsonContext jsonContext = Ebean.json();
+    JsonContext jsonContext = DB.json();
     JsonWriteOptions options = JsonWriteOptions.parsePath("(id,status,name)");
 
     jsonContext.toJson(map, options);
@@ -66,11 +66,11 @@ public class TestJsonMap extends BaseTestCase {
     PathProperties pathProperties =
       PathProperties.parse("(id,status,name,shippingAddress(id,line1,city),billingAddress(*),contacts(*))");
 
-    List<Customer> customers = Ebean.find(Customer.class)
+    List<Customer> customers = DB.find(Customer.class)
       .apply(pathProperties)
       .findList();
 
-    Ebean.json().toJson(customers, pathProperties);
+    DB.json().toJson(customers, pathProperties);
 
     // Assert.assertTrue(jsonString.indexOf("{\"1\":") > -1);
     // Assert.assertTrue(jsonString.indexOf("{\"id\":1,\"status\":\"NEW\",\"name\":\"Rob\"},")
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestJsonSimple.java b/ebean-test/src/test/java/org/tests/text/json/TestJsonSimple.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/text/json/TestJsonSimple.java
rename to ebean-test/src/test/java/org/tests/text/json/TestJsonSimple.java
index d64a4b702..f635d926b 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestJsonSimple.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestJsonSimple.java
@@ -1,23 +1,18 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.EJson;
 import io.ebean.text.json.JsonContext;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.LineNumberReader;
-import java.io.Reader;
+import java.io.*;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestJsonSimple extends BaseTestCase {
 
   @SuppressWarnings("unchecked")
@@ -40,28 +35,27 @@ public class TestJsonSimple extends BaseTestCase {
 
     Object el = EJson.parse(jsonText);
     assertThat(el).isNotNull();
-    
+
     Map<String, Object> e2 = EJson.parseObject("{\"a\":12, \"name\":{\"first\":\"rob\", \"last\":\"byg\"}}");
 
-    Assert.assertEquals(12L, e2.get("a"));
-    Assert.assertEquals("rob", ((Map<String, Object>) e2.get("name")).get("first"));
+    assertEquals(12L, e2.get("a"));
+    assertEquals("rob", ((Map<String, Object>) e2.get("name")).get("first"));
 
     Map<String, String> m = new LinkedHashMap<>();
     m.put("hello", "rob");
     m.put("test", "me");
 
-    JsonContext jsonContext = Ebean.json();
+    JsonContext jsonContext = DB.json();
     jsonContext.toJson(m);
 
     String s = "{\"parishId\":\"18\",\"contentId\":null,\"contentStatus\":null,\"contentType\":\"pg-hello\",\"content\":\"asd\"}";
 
     Object jsonElement = EJson.parse(s);
-    Assert.assertNotNull(jsonElement);
+    assertNotNull(jsonElement);
 
     Map<String, Object> e3 = EJson.parseObject("{\"name\":\"\\u60a8\\u597d\"}");
 
-    Assert.assertTrue(((String) e3.get("name")).length() == 2);
-
+    assertTrue(((String) e3.get("name")).length() == 2);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestJsonSomeEnumWithToString.java b/ebean-test/src/test/java/org/tests/text/json/TestJsonSomeEnumWithToString.java
similarity index 58%
rename from ebean-core/src/test/java/org/tests/text/json/TestJsonSomeEnumWithToString.java
rename to ebean-test/src/test/java/org/tests/text/json/TestJsonSomeEnumWithToString.java
index be569ac77..08f171196 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestJsonSomeEnumWithToString.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestJsonSomeEnumWithToString.java
@@ -1,34 +1,32 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.SomeEnum;
 import org.tests.model.basic.SomeEnumBean;
-import org.junit.Assert;
-import org.junit.Test;
 
-import java.io.IOException;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestJsonSomeEnumWithToString extends BaseTestCase {
 
   @Test
-  public void testJsonConversion() throws IOException {
+  public void testJsonConversion() {
 
     SomeEnumBean bean = new SomeEnumBean();
     bean.setId(100l);
     bean.setName("Some name");
     bean.setSomeEnum(SomeEnum.ALPHA);
 
-    JsonContext json = Ebean.json();
+    JsonContext json = DB.json();
     String jsonContent = json.toJson(bean);
 
     SomeEnumBean bean2 = json.toBean(SomeEnumBean.class, jsonContent);
 
-    Assert.assertEquals(bean.getSomeEnum(), bean2.getSomeEnum());
-    Assert.assertEquals(bean.getName(), bean2.getName());
-    Assert.assertEquals(bean.getId(), bean2.getId());
-
+    assertEquals(bean.getSomeEnum(), bean2.getSomeEnum());
+    assertEquals(bean.getName(), bean2.getName());
+    assertEquals(bean.getId(), bean2.getId());
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonBeanReadVisitor.java b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonBeanReadVisitor.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/text/json/TestTextJsonBeanReadVisitor.java
rename to ebean-test/src/test/java/org/tests/text/json/TestTextJsonBeanReadVisitor.java
index 8ecef61fc..2d1d5df3a 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonBeanReadVisitor.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonBeanReadVisitor.java
@@ -1,17 +1,18 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.io.StringReader;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestTextJsonBeanReadVisitor extends BaseTestCase {
 
   @Test
@@ -19,14 +20,14 @@ public class TestTextJsonBeanReadVisitor extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class)
+    List<Customer> list = DB.find(Customer.class)
       .select("id, name, status, shippingAddress")
       .fetch("billingAddress", "line1, city")
       .fetch("billingAddress.country", "*")
       .fetch("contacts", "firstName,email")
       .order().desc("id").findList();
 
-    JsonContext json = Ebean.json();
+    JsonContext json = DB.json();
 
 
     String s = json.toJson(list);
@@ -36,7 +37,7 @@ public class TestTextJsonBeanReadVisitor extends BaseTestCase {
     StringReader reader = new StringReader(s);
     List<Customer> mList2 = json.toList(Customer.class, reader);
 
-    Assert.assertEquals(mList.size(), mList2.size());
+    assertEquals(mList.size(), mList2.size());
   }
 
 
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonCompoundType.java b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonCompoundType.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/text/json/TestTextJsonCompoundType.java
rename to ebean-test/src/test/java/org/tests/text/json/TestTextJsonCompoundType.java
index 8c39075a5..00dbae51a 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonCompoundType.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonCompoundType.java
@@ -5,7 +5,7 @@ package org.tests.text.json;
 //import org.junit.Assert;
 
 import io.ebean.BaseTestCase;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 //
 //import com.avaje.ebean.Ebean;
@@ -31,7 +31,7 @@ public class TestTextJsonCompoundType extends BaseTestCase {
 //    p.setSalary(new Money("12200"));
 //    p.setCmoney(new CMoney(new Money("12"), NZD));
 //
-//    JsonContext jsonContext = Ebean.createJsonContext();
+//    JsonContext jsonContext = DB.json();
 //
 //    String jsonString = jsonContext.toJson(p, true);
 //    System.out.println(jsonString);
diff --git a/ebean-test/src/test/java/org/tests/text/json/TestTextJsonInheritance.java b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonInheritance.java
new file mode 100644
index 000000000..5c1f02cd3
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonInheritance.java
@@ -0,0 +1,60 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.text.json.JsonContext;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TestTextJsonInheritance extends BaseTestCase {
+
+  @Test
+  public void parseJson_when_inheritanceType_outOfOrderDtype() {
+
+    String fom = "{\"id\":90,\"name\":\"Frank\",\"vehicle\":{\"id\":42,\"licenseNumber\":\"T100\",\"capacity\":99.0,\"dtype\":\"T\"}}";
+
+    VehicleDriver driver1 = DB.json().toBean(VehicleDriver.class, fom);
+    assertThat(driver1.getVehicle()).isInstanceOf(Truck.class);
+    assertThat(driver1.getVehicle().getLicenseNumber()).isEqualTo("T100");
+  }
+
+  @Test
+  public void test() {
+
+    setupData();
+
+    List<Vehicle> list = DB.find(Vehicle.class).setAutoTune(false).findList();
+
+    assertEquals(2, list.size());
+
+    JsonContext jsonContext = DB.json();
+    String jsonString = jsonContext.toJson(list);
+
+    List<Vehicle> rebuiltList = jsonContext.toList(Vehicle.class, jsonString);
+
+    assertEquals(2, rebuiltList.size());
+  }
+
+  private void setupData() {
+    DB.createUpdate(CarAccessory.class, "delete from CarAccessory").execute();
+    DB.createUpdate(CarFuse.class, "delete from CarFuse").execute();
+    DB.createUpdate(Trip.class, "delete from trip").execute();
+    DB.createUpdate(VehicleDriver.class, "delete from vehicleDriver").execute();
+    DB.createUpdate(Vehicle.class, "delete from vehicle").execute();
+
+    Car c = new Car();
+    c.setLicenseNumber("C6788");
+    c.setDriver("CarDriver");
+    DB.save(c);
+
+    Truck t = new Truck();
+    t.setLicenseNumber("T1098");
+    t.setCapacity(20D);
+    DB.save(t);
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonInsertUpdate.java b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonInsertUpdate.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/text/json/TestTextJsonInsertUpdate.java
rename to ebean-test/src/test/java/org/tests/text/json/TestTextJsonInsertUpdate.java
index d11aba2ee..70feaf335 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonInsertUpdate.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonInsertUpdate.java
@@ -1,10 +1,10 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
 import io.ebean.util.StringHelper;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -19,25 +19,25 @@ public class TestTextJsonInsertUpdate extends BaseTestCase {
 
     String json0 = "{\"name\":\"InsJson\",\"status\":\"NEW\"}";
 
-    JsonContext jsonContext = Ebean.json();
+    JsonContext jsonContext = DB.json();
 
     // insert
     Customer c0 = jsonContext.toBean(Customer.class, json0);
-    Ebean.save(c0);
+    DB.save(c0);
 
     // update with optimistic concurrency checking
     String j0 = jsonContext.toJson(c0);
     String j1 = StringHelper.replace(j0, "InsJson", "Mod1");
     Customer c1 = jsonContext.toBean(Customer.class, j1);
-    Ebean.update(c1);
+    DB.update(c1);
 
     // update with no optimistic concurrency checking
     String j2 = "{\"id\":" + c0.getId() + ",\"name\":\"ModIns\",\"status\":\"ACTIVE\"}";
     Customer c2 = jsonContext.toBean(Customer.class, j2);
-    Ebean.update(c2);
+    DB.update(c2);
 
     // cleanup
-    Ebean.delete(Customer.class, c0.getId());
+    DB.delete(Customer.class, c0.getId());
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonInvokeLazy.java b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonInvokeLazy.java
similarity index 65%
rename from ebean-core/src/test/java/org/tests/text/json/TestTextJsonInvokeLazy.java
rename to ebean-test/src/test/java/org/tests/text/json/TestTextJsonInvokeLazy.java
index ee41b162e..bc7ff3251 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonInvokeLazy.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonInvokeLazy.java
@@ -1,34 +1,33 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
 import io.ebean.text.json.JsonWriteOptions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Before;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.List;
 
 public class TestTextJsonInvokeLazy extends BaseTestCase {
 
-  @Before
+  @BeforeEach
   public void clearBeanCache() {
-    server().getPluginApi().getBeanType(Customer.class).clearBeanCache();
+    server().pluginApi().beanType(Customer.class).clearBeanCache();
   }
-  
+
   @Test
   public void test() throws IOException {
-
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class).select("name").findList();
+    List<Customer> list = DB.find(Customer.class).select("name").findList();
 
     JsonWriteOptions opt = JsonWriteOptions.parsePath("name, status");
 
-    JsonContext jsonContext = Ebean.json();
+    JsonContext jsonContext = DB.json();
     jsonContext.toJson(list, opt);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonReadManyLazyLoad.java b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonReadManyLazyLoad.java
similarity index 61%
rename from ebean-core/src/test/java/org/tests/text/json/TestTextJsonReadManyLazyLoad.java
rename to ebean-test/src/test/java/org/tests/text/json/TestTextJsonReadManyLazyLoad.java
index d7b7bf4e6..c73264234 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonReadManyLazyLoad.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonReadManyLazyLoad.java
@@ -1,29 +1,30 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.PathProperties;
 import io.ebean.text.json.JsonContext;
 import io.ebean.text.json.JsonWriteOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class TestTextJsonReadManyLazyLoad extends BaseTestCase {
 
   @Test
-  public void test_lazyLoadBoth() throws IOException {
+  public void test_lazyLoadBoth() {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class).select("id, status, shippingAddress").order()
+    List<Customer> list = DB.find(Customer.class).select("id, status, shippingAddress").order()
       .desc("id").findList();
 
-    JsonContext json = Ebean.json();
+    JsonContext json = DB.json();
 
     // test that lazy loading on
     PathProperties pp = PathProperties.parse("(id,name,contacts(firstName))");
@@ -31,9 +32,8 @@ public class TestTextJsonReadManyLazyLoad extends BaseTestCase {
     o.setPathProperties(pp);
 
     String s = json.toJson(list, o);
-    Assert.assertTrue(s.contains("\"contacts\""));
-    Assert.assertTrue(s.contains("\"name\""));
-
+    assertTrue(s.contains("\"contacts\""));
+    assertTrue(s.contains("\"name\""));
   }
 
   @Test
@@ -41,10 +41,10 @@ public class TestTextJsonReadManyLazyLoad extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class).select("id, status, shippingAddress")
+    List<Customer> list = DB.find(Customer.class).select("id, status, shippingAddress")
       .fetch("contacts").order().desc("id").findList();
 
-    JsonContext json = Ebean.json();
+    JsonContext json = DB.json();
 
     // test that lazy loading on
     PathProperties pp = PathProperties.parse("(id,name,contacts(firstName))");
@@ -52,21 +52,20 @@ public class TestTextJsonReadManyLazyLoad extends BaseTestCase {
     o.setPathProperties(pp);
 
     String s = json.toJson(list, o);
-    Assert.assertTrue(s.contains("\"contacts\""));
-    Assert.assertTrue(s.contains("\"name\""));
-
+    assertTrue(s.contains("\"contacts\""));
+    assertTrue(s.contains("\"name\""));
   }
 
   @Test
-  public void test_lazyLoadContacts() throws IOException {
+  public void test_lazyLoadContacts() {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class).select("id, name, status, shippingAddress")
+    List<Customer> list = DB.find(Customer.class).select("id, name, status, shippingAddress")
       // .fetch("contacts")
       .order().desc("id").findList();
 
-    JsonContext json = Ebean.json();
+    JsonContext json = DB.json();
 
     // test that lazy loading on
     PathProperties pp = PathProperties.parse("(id,name,contacts(firstName))");
@@ -74,9 +73,8 @@ public class TestTextJsonReadManyLazyLoad extends BaseTestCase {
     o.setPathProperties(pp);
 
     String s = json.toJson(list, o);
-    Assert.assertTrue(s.contains("\"contacts\""));
-    Assert.assertTrue(s.contains("\"name\""));
-
+    assertTrue(s.contains("\"contacts\""));
+    assertTrue(s.contains("\"name\""));
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonReferenceBean.java b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonReferenceBean.java
similarity index 67%
rename from ebean-core/src/test/java/org/tests/text/json/TestTextJsonReferenceBean.java
rename to ebean-test/src/test/java/org/tests/text/json/TestTextJsonReferenceBean.java
index d73f561ed..0f0f66f02 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonReferenceBean.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonReferenceBean.java
@@ -2,22 +2,23 @@ package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.EntityBean;
 import io.ebean.text.json.JsonContext;
 import io.ebean.text.json.JsonWriteOptions;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.Product;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestTextJsonReferenceBean extends BaseTestCase {
 
   @Test
@@ -25,13 +26,13 @@ public class TestTextJsonReferenceBean extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
 
-    JsonContext jsonContext = Ebean.json();
+    JsonContext jsonContext = DB.json();
 
-    Product product = Ebean.getReference(Product.class, 1);
+    Product product = DB.reference(Product.class, 1);
 
-    BeanState beanState0 = Ebean.getBeanState(product);
+    BeanState beanState0 = DB.beanState(product);
     if (!beanState0.isReference()) {
       // got a cached value from beanCache
 
@@ -41,24 +42,23 @@ public class TestTextJsonReferenceBean extends BaseTestCase {
 
       Product refProd = jsonContext.toBean(Product.class, jsonString);
 
-      BeanDescriptor<Product> prodDesc = server.getBeanDescriptor(Product.class);
+      BeanDescriptor<Product> prodDesc = server.descriptor(Product.class);
       EntityBean eb = (EntityBean) refProd;
       prodDesc.isReference(eb._ebean_getIntercept());
 
-      BeanState beanState = Ebean.getBeanState(refProd);
-      Assert.assertTrue(beanState.isNew());
+      BeanState beanState = DB.beanState(refProd);
+      assertTrue(beanState.isNew());
 
       String name = refProd.getName();
-      Assert.assertNull(name);
+      assertNull(name);
 
       // Set to be 'loaded' to invoke lazy loading
       beanState.setLoaded();
       String name2 = refProd.getName();
-      Assert.assertNotNull(name2);
-
+      assertNotNull(name2);
     }
 
-    List<Order> orders = Ebean.find(Order.class)
+    List<Order> orders = DB.find(Order.class)
       // .setUseCache(false)
       .select("status, orderDate, shipDate, customer").fetch("details", "*")
       // .fetch("details.product","id")
@@ -73,11 +73,9 @@ public class TestTextJsonReferenceBean extends BaseTestCase {
     Order o2 = jsonContext.toBean(Order.class, jsonOrder);
     Customer customer = o2.getCustomer();
 
-    BeanDescriptor<Customer> custDesc = server.getBeanDescriptor(Customer.class);
-
-    Assert.assertTrue(custDesc.isReference(((EntityBean) customer)._ebean_getIntercept()));
-
+    BeanDescriptor<Customer> custDesc = server.descriptor(Customer.class);
 
+    assertTrue(custDesc.isReference(((EntityBean) customer)._ebean_getIntercept()));
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonSimple.java b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonSimple.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/text/json/TestTextJsonSimple.java
rename to ebean-test/src/test/java/org/tests/text/json/TestTextJsonSimple.java
index f77ff3fd8..3f4da80e7 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonSimple.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonSimple.java
@@ -1,24 +1,23 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.text.PathProperties;
 import io.ebean.text.json.JsonContext;
 import io.ebean.text.json.JsonReadBeanVisitor;
 import io.ebean.text.json.JsonReadOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Address;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestTextJsonSimple extends BaseTestCase {
 
@@ -63,20 +62,20 @@ public class TestTextJsonSimple extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class)
+    List<Customer> list = DB.find(Customer.class)
       .select("id, name, status, shippingAddress")
       .fetch("billingAddress", "line1, city").fetch("billingAddress.country", "*")
       .fetch("contacts", "firstName,email")
       .order().desc("id").findList();
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     JsonContext json = server.json();
 
     String jsonOutput = json.toJson(list);
 
     // check that transient fields are included by default in the JSON output
-    Assert.assertTrue(jsonOutput.contains("\"selected\":"));
+    assertTrue(jsonOutput.contains("\"selected\":"));
 
     List<Customer> mList = json.toList(Customer.class, jsonOutput);
     assertEquals(list.size(), mList.size());
@@ -101,11 +100,11 @@ public class TestTextJsonSimple extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class)
+    List<Customer> list = DB.find(Customer.class)
       .select("id, name")
       .order().desc("id").findList();
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     JsonContext json = server.json();
 
@@ -113,7 +112,7 @@ public class TestTextJsonSimple extends BaseTestCase {
     String jsonOutput = json.toJson(list);
 
     // check that transient fields are included by default in the JSON output
-    Assert.assertTrue(jsonOutput.contains("\"selected\":"));
+    assertTrue(jsonOutput.contains("\"selected\":"));
 
     List<Customer> mList = json.toList(Customer.class, jsonOutput);
     assertEquals(list.size(), mList.size());
@@ -124,11 +123,11 @@ public class TestTextJsonSimple extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class)
+    List<Customer> list = DB.find(Customer.class)
       .select("id, name")
       .order().desc("id").findList();
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     JsonContext json = server.json();
 
@@ -136,13 +135,13 @@ public class TestTextJsonSimple extends BaseTestCase {
     String jsonOutput = json.toJson(list, pathProperties);
 
     // check that transient fields are included by explicit pathProperties
-    Assert.assertTrue(jsonOutput.contains("\"selected\":"));
+    assertTrue(jsonOutput.contains("\"selected\":"));
 
     pathProperties = PathProperties.parse("(id,name)");
     jsonOutput = json.toJson(list, pathProperties);
 
     // check that transient fields are NOT included when explicitly excluded by pathProperties
-    Assert.assertFalse(jsonOutput.contains("\"selected\":"));
+    assertFalse(jsonOutput.contains("\"selected\":"));
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonSuperSimple.java b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonSuperSimple.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/text/json/TestTextJsonSuperSimple.java
rename to ebean-test/src/test/java/org/tests/text/json/TestTextJsonSuperSimple.java
index 59040b598..f0f41ba10 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonSuperSimple.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonSuperSimple.java
@@ -1,17 +1,18 @@
 package org.tests.text.json;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.text.json.JsonContext;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestTextJsonSuperSimple extends BaseTestCase {
 
   @Test
@@ -19,10 +20,10 @@ public class TestTextJsonSuperSimple extends BaseTestCase {
 
     ResetBasicData.reset();
 
-    List<Customer> list = Ebean.find(Customer.class).select("id, name").order().desc("id")
+    List<Customer> list = DB.find(Customer.class).select("id, name").order().desc("id")
       .findList();
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     JsonContext json = server.json();
 
@@ -31,7 +32,7 @@ public class TestTextJsonSuperSimple extends BaseTestCase {
 
       String s = json.toJson(customer);
       int statusPos = s.indexOf("status");
-      Assert.assertEquals(-1, statusPos);
+      assertEquals(-1, statusPos);
     }
 
   }
diff --git a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonUpdateCascade.java b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonUpdateCascade.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/text/json/TestTextJsonUpdateCascade.java
rename to ebean-test/src/test/java/org/tests/text/json/TestTextJsonUpdateCascade.java
index ff79d7fac..1106d660f 100644
--- a/ebean-core/src/test/java/org/tests/text/json/TestTextJsonUpdateCascade.java
+++ b/ebean-test/src/test/java/org/tests/text/json/TestTextJsonUpdateCascade.java
@@ -1,23 +1,18 @@
 package org.tests.text.json;
 
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.TransactionalTestCase;
 import io.ebean.text.json.JsonContext;
-import org.tests.model.basic.Customer;
-import org.tests.model.basic.MRole;
-import org.tests.model.basic.MUser;
-import org.tests.model.basic.Order;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.*;
 import org.tests.model.basic.Order.Status;
-import org.tests.model.basic.OrderDetail;
-import org.tests.model.basic.Product;
-import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.io.IOException;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestTextJsonUpdateCascade extends TransactionalTestCase {
 
   @Test
@@ -25,17 +20,17 @@ public class TestTextJsonUpdateCascade extends TransactionalTestCase {
 
     Customer c0 = ResetBasicData.createCustAndOrder("Test Json");
 
-    Customer c2 = Ebean.getReference(Customer.class, c0.getId());
+    Customer c2 = DB.reference(Customer.class, c0.getId());
     List<Order> orders = c2.getOrders();
 
-    Assert.assertEquals(1, orders.size());
+    assertEquals(1, orders.size());
 
     Order order = orders.get(0);
     int size = order.getDetails().size();
 
-    Assert.assertTrue(size >= 3);
+    assertTrue(size >= 3);
 
-    Customer cref = Ebean.getReference(Customer.class, c0.getId());
+    Customer cref = DB.reference(Customer.class, c0.getId());
     order.setCustomer(cref);
     order.setStatus(Status.SHIPPED);
 
@@ -45,14 +40,14 @@ public class TestTextJsonUpdateCascade extends TransactionalTestCase {
 
     // remove one of the details...
     OrderDetail removedDetail = order.getDetails().remove(2);
-    Assert.assertNotNull(removedDetail);
+    assertNotNull(removedDetail);
 
-    Product p = Ebean.getReference(Product.class, 1);
+    Product p = DB.reference(Product.class, 1);
     OrderDetail newDetail = new OrderDetail(p, 899, 12.12d);
     // newDetail.setOrder(order);
     order.addDetail(newDetail);
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     JsonContext jsonContext = server.json();
     String jsonString = jsonContext.toJson(order);
@@ -63,15 +58,15 @@ public class TestTextJsonUpdateCascade extends TransactionalTestCase {
 
     MRole r1 = new MRole();
     r1.setRoleName("rolej1");
-    Ebean.save(r1);
+    DB.save(r1);
 
     MRole r2 = new MRole();
     r2.setRoleName("rolej2");
-    Ebean.save(r2);
+    DB.save(r2);
 
     MRole r3 = new MRole();
     r3.setRoleName("rolej3");
-    Ebean.save(r3);
+    DB.save(r3);
 
     MUser u0 = new MUser();
     u0.setUserName("userj1");
@@ -79,7 +74,7 @@ public class TestTextJsonUpdateCascade extends TransactionalTestCase {
     u0.addRole(r2);
     u0.addRole(r3);
 
-    Ebean.save(u0);
+    DB.save(u0);
 
     jsonContext.toJson(u0);
 
diff --git a/ebean-core/src/test/java/org/tests/timezone/TimezoneTests.java b/ebean-test/src/test/java/org/tests/timezone/TimezoneTests.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/timezone/TimezoneTests.java
rename to ebean-test/src/test/java/org/tests/timezone/TimezoneTests.java
index 7f144f77f..67c700fbc 100644
--- a/ebean-core/src/test/java/org/tests/timezone/TimezoneTests.java
+++ b/ebean-test/src/test/java/org/tests/timezone/TimezoneTests.java
@@ -1,15 +1,11 @@
 package org.tests.timezone;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Timestamp;
+import java.sql.*;
 import java.util.Calendar;
 import java.util.TimeZone;
 
@@ -23,7 +19,7 @@ public class TimezoneTests {
   public TimezoneTests() {
   }
 
-  @Ignore
+  @Disabled
   @Test
   public void rawJdbc() throws SQLException {
 
@@ -45,10 +41,10 @@ public class TimezoneTests {
 
   private void fetch() throws SQLException {
     try (
-        Transaction transaction = Ebean.beginTransaction();
-        Connection connection = transaction.getConnection();
-        PreparedStatement statement = connection.prepareStatement("select * from tztest");
-        ResultSet resultSet = statement.executeQuery()) {
+      Transaction transaction = DB.beginTransaction();
+      Connection connection = transaction.connection();
+      PreparedStatement statement = connection.prepareStatement("select * from tztest");
+      ResultSet resultSet = statement.executeQuery()) {
 
       while (resultSet.next()) {
         System.out.println(" zone:" + resultSet.getString("zone"));
@@ -79,9 +75,9 @@ public class TimezoneTests {
     }
 
     try (
-        Transaction transaction = Ebean.beginTransaction();
-        Connection connection = transaction.getConnection();
-        PreparedStatement statement = connection.prepareStatement(insert)) {
+      Transaction transaction = DB.beginTransaction();
+      Connection connection = transaction.connection();
+      PreparedStatement statement = connection.prepareStatement(insert)) {
       statement.setString(1, zone);
       statement.setTimestamp(2, nowTs);
       statement.setTimestamp(3, nowTs);
diff --git a/ebean-core/src/test/java/org/tests/timezone/TzBean.java b/ebean-test/src/test/java/org/tests/timezone/TzBean.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/timezone/TzBean.java
rename to ebean-test/src/test/java/org/tests/timezone/TzBean.java
diff --git a/ebean-core/src/test/java/org/tests/timezone/TzBeanTests.java b/ebean-test/src/test/java/org/tests/timezone/TzBeanTests.java
similarity index 92%
rename from ebean-core/src/test/java/org/tests/timezone/TzBeanTests.java
rename to ebean-test/src/test/java/org/tests/timezone/TzBeanTests.java
index ff50ee5a5..7c4739d4f 100644
--- a/ebean-core/src/test/java/org/tests/timezone/TzBeanTests.java
+++ b/ebean-test/src/test/java/org/tests/timezone/TzBeanTests.java
@@ -1,8 +1,8 @@
 package org.tests.timezone;
 
-import io.ebean.Ebean;
-import org.junit.Ignore;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
 import java.util.List;
@@ -35,7 +35,7 @@ public class TzBeanTests {
   /**
    * Run this 5 times with different modes.
    */
-  @Ignore
+  @Disabled
   @Test
   public void insert_one_at_a_time() {
 
@@ -59,13 +59,13 @@ public class TzBeanTests {
     bean.setTs(nowTs);
     bean.setTstz(nowTs);
 
-    Ebean.save(bean);
+    DB.save(bean);
   }
 
   /**
    * In separate JVM/execution fetch the beans with various timezones etc.
    */
-  @Ignore
+  @Disabled
   @Test
   public void fetch_beans() {
 
@@ -77,7 +77,7 @@ public class TzBeanTests {
     // set the Calendar time zone to use in JDBC calls
     System.setProperty("ebean.dataTimeZone", "UTC");
 
-    List<TzBean> list = Ebean.find(TzBean.class)
+    List<TzBean> list = DB.find(TzBean.class)
       .findList();
 
     for (TzBean bean : list) {
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestBatchModelFlush.java b/ebean-test/src/test/java/org/tests/transaction/TestBatchModelFlush.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/transaction/TestBatchModelFlush.java
rename to ebean-test/src/test/java/org/tests/transaction/TestBatchModelFlush.java
index 0330a103b..639b52c69 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestBatchModelFlush.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestBatchModelFlush.java
@@ -2,13 +2,11 @@ package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.Transaction;
 import io.ebean.annotation.Transactional;
 import io.ebean.config.dbplatform.IdType;
-
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.m2m.MnyB;
 import org.tests.model.m2m.MnyTopic;
 import org.tests.model.m2m.Role;
@@ -36,7 +34,7 @@ public class TestBatchModelFlush extends BaseTestCase {
     bean2.db().flush();
 
     new MnyB("TestBatchModelFlush_4").save();
-    Ebean.flush();
+    DB.flush();
 
     // the rest is flushed on commit
     new MnyB("TestBatchModelFlush_5").save();
@@ -45,7 +43,7 @@ public class TestBatchModelFlush extends BaseTestCase {
   @Test
   public void multipleTopLevel_expect_singleFlush() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     // 2 unrelated "top level" beans being persisted
     MnyB m0 = new MnyB("BatchMultipleTop_0");
@@ -70,7 +68,7 @@ public class TestBatchModelFlush extends BaseTestCase {
       transaction.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     // DEBUG io.ebean.SUM - txn[1001] BatchControl flush [MnyB:100 i:2, Role:101 i:2, MnyTopic:102 i:2]
 
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestBatchPersistCascade.java b/ebean-test/src/test/java/org/tests/transaction/TestBatchPersistCascade.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/transaction/TestBatchPersistCascade.java
rename to ebean-test/src/test/java/org/tests/transaction/TestBatchPersistCascade.java
index 2849adcb5..7f575924a 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestBatchPersistCascade.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestBatchPersistCascade.java
@@ -1,13 +1,13 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.UTDetail;
@@ -15,7 +15,7 @@ import org.tests.model.basic.UTMaster;
 
 import java.util.List;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestBatchPersistCascade extends BaseTestCase {
 
@@ -25,9 +25,9 @@ public class TestBatchPersistCascade extends BaseTestCase {
   @IgnorePlatform(Platform.HANA)
   public void test() {
 
-    EbeanServer ebeanServer = Ebean.getServer(null);
+    Database ebeanServer = DB.getDefault();
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     Transaction txn = ebeanServer.beginTransaction();
     try {
@@ -48,7 +48,7 @@ public class TestBatchPersistCascade extends BaseTestCase {
       txn.end();
     }
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
     assertTrue(loggedSql.size() > 2);
 
 
@@ -58,7 +58,7 @@ public class TestBatchPersistCascade extends BaseTestCase {
 
   private void testUpdates() {
 
-    EbeanServer server = Ebean.getServer(null);
+    Database server = DB.getDefault();
 
     List<UTMaster> list = server.find(UTMaster.class).fetch("details").findList();
 
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestBeanStateReset.java b/ebean-test/src/test/java/org/tests/transaction/TestBeanStateReset.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/transaction/TestBeanStateReset.java
rename to ebean-test/src/test/java/org/tests/transaction/TestBeanStateReset.java
index a5432596e..2fcb01543 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestBeanStateReset.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestBeanStateReset.java
@@ -1,20 +1,19 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.tests.model.m2m.MnyB;
-import org.tests.model.m2m.MnyC;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.tests.model.m2m.MnyB;
+import org.tests.model.m2m.MnyC;
 
 import javax.persistence.PersistenceException;
 import java.util.List;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestBeanStateReset extends BaseTestCase {
 
@@ -37,14 +36,14 @@ public class TestBeanStateReset extends BaseTestCase {
     } catch (PersistenceException e) {
       logger.info("expected error " + e.getMessage());
 
-      Ebean.getBeanState(b).resetForInsert();
+      DB.beanState(b).resetForInsert();
       b.getCs().clear();
 
-      LoggedSqlCollector.start();
+      LoggedSql.start();
       b.setName("mod");
       b.save();
 
-      List<String> sql = LoggedSqlCollector.stop();
+      List<String> sql = LoggedSql.stop();
       assertSql(sql.get(0)).contains("insert into mny_b (id, name, version, when_created, when_modified, a_id) values (");
     }
 
@@ -60,7 +59,7 @@ public class TestBeanStateReset extends BaseTestCase {
     MnyB b = new MnyB();
     b.getCs().add(c);
 
-    Transaction transaction = Ebean.beginTransaction();
+    Transaction transaction = DB.beginTransaction();
     try {
       // turn off cascade ...
       transaction.setPersistCascade(false);
@@ -92,7 +91,7 @@ public class TestBeanStateReset extends BaseTestCase {
     }
 
     // assert our insert prior to the commitAndContinue succeeded
-    MnyB madeIt = Ebean.find(MnyB.class, b.getId());
+    MnyB madeIt = DB.find(MnyB.class, b.getId());
     assertNotNull(madeIt);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestBeginTransactionWithExisting.java b/ebean-test/src/test/java/org/tests/transaction/TestBeginTransactionWithExisting.java
similarity index 59%
rename from ebean-core/src/test/java/org/tests/transaction/TestBeginTransactionWithExisting.java
rename to ebean-test/src/test/java/org/tests/transaction/TestBeginTransactionWithExisting.java
index eb61b7010..2e0d05ef9 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestBeginTransactionWithExisting.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestBeginTransactionWithExisting.java
@@ -1,42 +1,41 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.TxIsolation;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import javax.persistence.PersistenceException;
 import java.sql.Connection;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class TestBeginTransactionWithExisting extends BaseTestCase {
 
   @Test
   public void testTransactionIsoLevels() {
-
     assertEquals(Transaction.READ_COMMITTED, Connection.TRANSACTION_READ_COMMITTED);
     assertEquals(Transaction.READ_UNCOMMITTED, Connection.TRANSACTION_READ_UNCOMMITTED);
     assertEquals(Transaction.REPEATABLE_READ, Connection.TRANSACTION_REPEATABLE_READ);
     assertEquals(Transaction.SERIALIZABLE, Connection.TRANSACTION_SERIALIZABLE);
   }
 
-  @Test(expected = PersistenceException.class)
+  @Test
   public void test() {
 
     assertEquals(Transaction.READ_COMMITTED, Connection.TRANSACTION_READ_COMMITTED);
-
-    Transaction txn = Ebean.beginTransaction();
-    try {
-
-      try (Transaction txn2 = Ebean.beginTransaction(TxIsolation.READ_COMMITED)) {
-        fail("Expected persitenceException here");
+    assertThrows(PersistenceException.class, () -> {
+      Transaction txn = DB.beginTransaction();
+      try {
+        try (Transaction txn2 = DB.beginTransaction(TxIsolation.READ_COMMITED)) {
+          fail("Expected persitenceException here");
+        }
+      } finally {
+        txn.end();
       }
-
-    } finally {
-      txn.end();
-    }
+    });
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestCommitAndContinue.java b/ebean-test/src/test/java/org/tests/transaction/TestCommitAndContinue.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/transaction/TestCommitAndContinue.java
rename to ebean-test/src/test/java/org/tests/transaction/TestCommitAndContinue.java
index 157a20056..144d8f5e3 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestCommitAndContinue.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestCommitAndContinue.java
@@ -1,19 +1,19 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
 import io.ebean.annotation.Transactional;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.m2m.MnyB;
 
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestCommitAndContinue extends BaseTestCase {
 
@@ -30,7 +30,7 @@ public class TestCommitAndContinue extends BaseTestCase {
     a.save();
 
     // commit at this point
-    Ebean.currentTransaction().commitAndContinue();
+    DB.currentTransaction().commitAndContinue();
 
     try {
       b.save();
@@ -40,10 +40,10 @@ public class TestCommitAndContinue extends BaseTestCase {
 
     } catch (IllegalStateException e) {
       // mark the transaction as rollback
-      Ebean.currentTransaction().setRollbackOnly();
+      DB.currentTransaction().setRollbackOnly();
 
       // use a different transaction to assert
-      EbeanServer server = Ebean.getDefaultServer();
+      Database server = DB.getDefault();
       try (Transaction anotherTxn = server.createTransaction()) {
         // success prior to commitAndContinue
         assertNotNull(server.find(MnyB.class, a.getId(), anotherTxn));
@@ -63,7 +63,7 @@ public class TestCommitAndContinue extends BaseTestCase {
     MnyB a = new MnyB("a100");
     MnyB b = new MnyB("b200");
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     Transaction txn = server.beginTransaction();
     try {
       a.save();
@@ -111,7 +111,7 @@ public class TestCommitAndContinue extends BaseTestCase {
     a.save();
 
     // commit at this point
-    Ebean.currentTransaction().commitAndContinue();
+    DB.currentTransaction().commitAndContinue();
 
     try {
       b.save();
@@ -121,10 +121,10 @@ public class TestCommitAndContinue extends BaseTestCase {
 
     } catch (IllegalStateException e) {
       // mark the transaction as rollback
-      Ebean.currentTransaction().setRollbackOnly();
+      DB.currentTransaction().setRollbackOnly();
 
       // use a different transaction to do something useful
-      EbeanServer server = Ebean.getDefaultServer();
+      Database server = DB.getDefault();
       Transaction txn2 = server.createTransaction();
       try {
         server.save(c, txn2);
@@ -136,7 +136,7 @@ public class TestCommitAndContinue extends BaseTestCase {
 
     // asserts
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     try (Transaction txnForAssert = server.createTransaction()) {
       // success prior to commitAndContinue
       assertNotNull(server.find(MnyB.class, a.getId(), txnForAssert));
@@ -156,7 +156,7 @@ public class TestCommitAndContinue extends BaseTestCase {
     MnyB b = new MnyB("b");
     MnyB c = new MnyB("c");
 
-    Transaction txn = Ebean.beginTransaction();
+    Transaction txn = DB.beginTransaction();
     try {
       a.save();
       txn.commitAndContinue();
@@ -181,7 +181,7 @@ public class TestCommitAndContinue extends BaseTestCase {
     new MnyB("a100").save();
     new MnyB("a101").save();
 
-    Ebean.currentTransaction().commitAndContinue();
+    DB.currentTransaction().commitAndContinue();
 
     new MnyB("a200").save();
     new MnyB("a201").save();
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestCreateTransactionWithIsolation.java b/ebean-test/src/test/java/org/tests/transaction/TestCreateTransactionWithIsolation.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/transaction/TestCreateTransactionWithIsolation.java
rename to ebean-test/src/test/java/org/tests/transaction/TestCreateTransactionWithIsolation.java
index cc42c1c3a..aff263bbd 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestCreateTransactionWithIsolation.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestCreateTransactionWithIsolation.java
@@ -1,14 +1,14 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class TestCreateTransactionWithIsolation extends BaseTestCase {
 
   @Test
   public void test() {
 
-//    EbeanServer server = Ebean.getServer(null);
+//    Database server = DB.getDefault();
 //    Transaction txn = server.createTransaction(TxIsolation.SERIALIZABLE);
 //    txn.end();
 
diff --git a/ebean-test/src/test/java/org/tests/transaction/TestDeleteFromPersistenceContext.java b/ebean-test/src/test/java/org/tests/transaction/TestDeleteFromPersistenceContext.java
new file mode 100644
index 000000000..a4b4ee099
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/transaction/TestDeleteFromPersistenceContext.java
@@ -0,0 +1,54 @@
+package org.tests.transaction;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebeaninternal.api.SpiTransaction;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.EBasicVer;
+import org.tests.model.basic.ResetBasicData;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestDeleteFromPersistenceContext extends BaseTestCase {
+
+  @Test
+  public void testDeleteBean() {
+
+    ResetBasicData.reset();
+
+    EBasicVer bean = new EBasicVer("Please Delete Me");
+    DB.save(bean);
+
+    SpiTransaction transaction = (SpiTransaction) DB.beginTransaction();
+    try {
+
+      EBasicVer bean2 = DB.find(EBasicVer.class, bean.getId());
+      assertNotSame(bean, bean2);
+
+      EBasicVer bean3 = DB.find(EBasicVer.class, bean.getId());
+      // same instance from PersistenceContext
+      assertSame(bean2, bean3);
+
+      Object bean4 = transaction.getPersistenceContext().get(EBasicVer.class, bean.getId());
+      assertSame(bean2, bean4);
+
+      DB.delete(bean2);
+
+      Object bean5 = transaction.getPersistenceContext().get(EBasicVer.class, bean.getId());
+      assertNull(bean5);
+
+      DB.commitTransaction();
+
+    } finally {
+      DB.endTransaction();
+    }
+
+    EBasicVer bean6 = DB.find(EBasicVer.class).where().eq("id", bean.getId()).findOne();
+    assertNull(bean6);
+
+    awaitL2Cache();
+    EBasicVer bean7 = DB.find(EBasicVer.class, bean.getId());
+    assertNull(bean7);
+  }
+
+}
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestExecuteComplete.java b/ebean-test/src/test/java/org/tests/transaction/TestExecuteComplete.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/transaction/TestExecuteComplete.java
rename to ebean-test/src/test/java/org/tests/transaction/TestExecuteComplete.java
index 6632816a5..be3b6557b 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestExecuteComplete.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestExecuteComplete.java
@@ -1,21 +1,17 @@
 package org.tests.transaction;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.DataIntegrityException;
-import io.ebean.Transaction;
-import io.ebean.TxScope;
+import io.ebean.*;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.annotation.Platform;
 import io.ebean.annotation.Transactional;
 import io.ebeaninternal.api.SpiTransaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.fail;
 
 public class TestExecuteComplete extends BaseTestCase {
 
@@ -27,7 +23,7 @@ public class TestExecuteComplete extends BaseTestCase {
     try {
       DB.execute(TxScope.required().setBatch(PersistBatch.ALL), () -> {
 
-        Customer customer = DB.getReference(Customer.class, 42424242L);
+        Customer customer = DB.reference(Customer.class, 42424242L);
         Order order = new Order();
         order.setCustomer(customer);
 
@@ -48,7 +44,7 @@ public class TestExecuteComplete extends BaseTestCase {
       DB.execute(TxScope.required().setBatch(PersistBatch.ALL), () ->
       DB.execute(() -> {
 
-          Customer customer = DB.getReference(Customer.class, 42424242L);
+          Customer customer = DB.reference(Customer.class, 42424242L);
           Order order = new Order();
           order.setCustomer(customer);
 
@@ -75,7 +71,7 @@ public class TestExecuteComplete extends BaseTestCase {
 
   @Transactional(batchSize = 10)
   private void errorOnCommit() {
-    Customer customer = DB.getReference(Customer.class, 42424242L);
+    Customer customer = DB.reference(Customer.class, 42424242L);
     Order order = new Order();
     order.setCustomer(customer);
 
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestInsertManyAndRef.java b/ebean-test/src/test/java/org/tests/transaction/TestInsertManyAndRef.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/transaction/TestInsertManyAndRef.java
rename to ebean-test/src/test/java/org/tests/transaction/TestInsertManyAndRef.java
index de123a74d..ecab276e9 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestInsertManyAndRef.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestInsertManyAndRef.java
@@ -1,10 +1,10 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.BBookmark;
 import org.tests.model.basic.BBookmarkUser;
-import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -30,6 +30,6 @@ public class TestInsertManyAndRef extends BaseTestCase {
     bookmarks.add(b1);
     bookmarks.add(b2);
 
-    Ebean.saveAll(bookmarks);
+    DB.saveAll(bookmarks);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestNested.java b/ebean-test/src/test/java/org/tests/transaction/TestNested.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/transaction/TestNested.java
rename to ebean-test/src/test/java/org/tests/transaction/TestNested.java
index d2ba0423b..1993c90be 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestNested.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestNested.java
@@ -1,8 +1,8 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import javax.persistence.PersistenceException;
 import java.util.concurrent.Callable;
@@ -15,7 +15,7 @@ public class TestNested extends BaseTestCase {
   public void testRunnableFail() {
 
     try {
-      Ebean.execute(this::willFail);
+      DB.execute(this::willFail);
     } catch (PersistenceException e) {
       assertThat(e.getMessage()).contains("test runnable rollback");
     }
@@ -25,20 +25,20 @@ public class TestNested extends BaseTestCase {
   public void testCallableFail() {
 
     try {
-      Ebean.execute(this::willFailCallable);
+      DB.execute(this::willFailCallable);
     } catch (PersistenceException e) {
       assertThat(e.getMessage()).contains("test callable rollback");
     }
   }
 
   private void willFail() {
-    Ebean.executeCall(() -> {
+    DB.executeCall(() -> {
       throw new RuntimeException("test runnable rollback");
     });
   }
 
   private void willFailCallable() {
-    Ebean.executeCall((Callable<String>) () -> {
+    DB.executeCall((Callable<String>) () -> {
       throw new Exception("test callable rollback");
     });
   }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequired.java b/ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequired.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequired.java
rename to ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequired.java
index ba8c3ecae..58b4c68c5 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequired.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequired.java
@@ -1,22 +1,18 @@
 package org.tests.transaction;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import io.ebean.Transaction;
-import io.ebean.TxScope;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Product;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class TestNestedBeginRequired extends BaseTestCase {
 
   Logger logger = LoggerFactory.getLogger(TestNestedBeginRequired.class);
 
-  EbeanServer server = Ebean.getServer(null);
+  Database server = DB.getDefault();
 
   @Test
   public void test() {
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequiredWithFailure.java b/ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequiredWithFailure.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequiredWithFailure.java
rename to ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequiredWithFailure.java
index 55aa39bc0..6f91cf2fd 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequiredWithFailure.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequiredWithFailure.java
@@ -1,23 +1,19 @@
 package org.tests.transaction;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import io.ebean.Transaction;
-import io.ebean.TxScope;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasic;
 import org.tests.model.basic.Product;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class TestNestedBeginRequiredWithFailure extends BaseTestCase {
 
   Logger logger = LoggerFactory.getLogger(TestNestedBeginRequiredWithFailure.class);
 
-  EbeanServer server = Ebean.getServer(null);
+  Database server = DB.getDefault();
 
   @Test
   public void test() {
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequiresNew.java b/ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequiresNew.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequiresNew.java
rename to ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequiresNew.java
index 8666fcffd..b7c7fd3e0 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequiresNew.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequiresNew.java
@@ -1,22 +1,18 @@
 package org.tests.transaction;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import io.ebean.Transaction;
-import io.ebean.TxScope;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Product;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class TestNestedBeginRequiresNew extends BaseTestCase {
 
   Logger logger = LoggerFactory.getLogger(TestNestedBeginRequiresNew.class);
 
-  EbeanServer server = Ebean.getServer(null);
+  Database server = DB.getDefault();
 
   @Test
   public void test() {
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequiresNewWithFailure.java b/ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequiresNewWithFailure.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequiresNewWithFailure.java
rename to ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequiresNewWithFailure.java
index f597ec347..927d3380a 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestNestedBeginRequiresNewWithFailure.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestNestedBeginRequiresNewWithFailure.java
@@ -1,22 +1,18 @@
 package org.tests.transaction;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import io.ebean.Transaction;
-import io.ebean.TxScope;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.tests.model.basic.Country;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Product;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class TestNestedBeginRequiresNewWithFailure extends BaseTestCase {
 
   Logger logger = LoggerFactory.getLogger(TestNestedBeginRequiresNewWithFailure.class);
 
-  EbeanServer server = Ebean.getServer(null);
+  Database server = DB.getDefault();
 
   @Test
   public void test() {
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestNestedMandatory.java b/ebean-test/src/test/java/org/tests/transaction/TestNestedMandatory.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/transaction/TestNestedMandatory.java
rename to ebean-test/src/test/java/org/tests/transaction/TestNestedMandatory.java
index de3184595..a1409cd32 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestNestedMandatory.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestNestedMandatory.java
@@ -1,12 +1,12 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.Transactional;
 import io.ebean.annotation.TxType;
 import io.ebean.meta.MetaTimedMetric;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -40,7 +40,7 @@ public class TestNestedMandatory extends BaseTestCase {
 
     @Transactional(label = "outer")
     void doOuter() {
-      outerTxn = Ebean.currentTransaction();
+      outerTxn = DB.currentTransaction();
 
       log.info("outer start ...{}", outerTxn);
       new Inner().doInner();
@@ -52,7 +52,7 @@ public class TestNestedMandatory extends BaseTestCase {
 
     @Transactional(type = TxType.MANDATORY)
     void doInner() {
-      Transaction innerTxn = Ebean.currentTransaction();
+      Transaction innerTxn = DB.currentTransaction();
       log.info("inner ...{}", innerTxn);
 
       assertThat(innerTxn).isSameAs(outerTxn);
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestNestedSubTransaction.java b/ebean-test/src/test/java/org/tests/transaction/TestNestedSubTransaction.java
similarity index 89%
rename from ebean-core/src/test/java/org/tests/transaction/TestNestedSubTransaction.java
rename to ebean-test/src/test/java/org/tests/transaction/TestNestedSubTransaction.java
index 313019b5f..44e8f7299 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestNestedSubTransaction.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestNestedSubTransaction.java
@@ -1,19 +1,14 @@
 package org.tests.transaction;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import io.ebean.PersistenceContextScope;
-import io.ebean.Transaction;
-import io.ebean.TxScope;
+import io.ebean.*;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestNestedSubTransaction extends BaseTestCase {
 
@@ -24,7 +19,7 @@ public class TestNestedSubTransaction extends BaseTestCase {
   @Test
   public void ebeanServer_commitTransaction_expect_sameAsTransactionCommit() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     EBasic bean = new EBasic("x1");
 
@@ -46,7 +41,7 @@ public class TestNestedSubTransaction extends BaseTestCase {
 
       try (Transaction txn2 = server.beginTransaction()) {
         bean.setName("barney");
-        Ebean.save(bean);
+        DB.save(bean);
         //txn2.commit();
         server.commitTransaction();
       }
@@ -69,7 +64,7 @@ public class TestNestedSubTransaction extends BaseTestCase {
   @Test
   public void nestedUseSavepoint_doubleNested_rollbackCommit() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     EBasic bean = new EBasic("start2");
 
@@ -85,7 +80,7 @@ public class TestNestedSubTransaction extends BaseTestCase {
 
         try (Transaction txn2 = server.beginTransaction()) {
           bean.setName("barney");
-          Ebean.save(bean);
+          DB.save(bean);
           txn2.commit();
         }
 
@@ -106,7 +101,7 @@ public class TestNestedSubTransaction extends BaseTestCase {
   @Test
   public void nestedUseSavepoint_doubleNested_commitRollback() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     EBasic bean = new EBasic("start3");
 
@@ -122,7 +117,7 @@ public class TestNestedSubTransaction extends BaseTestCase {
 
         try (Transaction txn2 = server.beginTransaction()) {
           bean.setName("barney3");
-          Ebean.save(bean);
+          DB.save(bean);
           txn2.rollback();
         }
 
@@ -143,7 +138,7 @@ public class TestNestedSubTransaction extends BaseTestCase {
   @Test
   public void nestedUseSavepoint_nested_RequiresNew() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     EBasic bean = new EBasic("start4");
 
@@ -179,7 +174,7 @@ public class TestNestedSubTransaction extends BaseTestCase {
   @Test
   public void nestedUseSavepoint() {
 
-    EbeanServer server = server();
+    Database server = server();
 
     EBasic bean = new EBasic("start1");
 
@@ -201,7 +196,7 @@ public class TestNestedSubTransaction extends BaseTestCase {
 
       try (Transaction txn2 = server.beginTransaction()) {
         bean.setName("barney");
-        Ebean.save(bean);
+        DB.save(bean);
         txn2.rollback();
       }
 
@@ -219,6 +214,6 @@ public class TestNestedSubTransaction extends BaseTestCase {
   }
 
   private void cleanup(EBasic bean) {
-    Ebean.delete(EBasic.class, bean.getId());
+    DB.delete(EBasic.class, bean.getId());
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestNestedTransaction.java b/ebean-test/src/test/java/org/tests/transaction/TestNestedTransaction.java
similarity index 59%
rename from ebean-core/src/test/java/org/tests/transaction/TestNestedTransaction.java
rename to ebean-test/src/test/java/org/tests/transaction/TestNestedTransaction.java
index 57d61c82d..5bc880902 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestNestedTransaction.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestNestedTransaction.java
@@ -1,10 +1,10 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.EBasic;
@@ -17,31 +17,31 @@ public class TestNestedTransaction extends BaseTestCase {
 
   private EBasic bean;
 
-  @Before
+  @BeforeEach
   public void init() {
     bean = new EBasic("new");
-    Ebean.save(bean);
+    DB.save(bean);
   }
 
   private void assertClean() {
-    EBasic myBean = Ebean.find(EBasic.class, bean.getId());
+    EBasic myBean = DB.find(EBasic.class, bean.getId());
     assertThat(myBean.getName()).isEqualTo("new");
   }
 
   private void assertModified() {
-    EBasic myBean = Ebean.find(EBasic.class, bean.getId());
+    EBasic myBean = DB.find(EBasic.class, bean.getId());
     assertThat(myBean.getName()).isEqualTo("modified");
   }
 
   private void modify() {
     bean.setName("modified");
-    Ebean.save(bean);
+    DB.save(bean);
   }
 
   // ===== level 0 =======
   @Test
   public void testNested_0() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
       modify();
       // no commit
     }
@@ -50,7 +50,7 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_1() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
       modify();
       txn0.commit();
     }
@@ -60,8 +60,8 @@ public class TestNestedTransaction extends BaseTestCase {
   // ===== level 1 =======
   @Test
   public void testNested_00() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
         modify();
         // no commit
       }
@@ -72,8 +72,8 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_01() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
         modify();
         // no commit
       }
@@ -93,8 +93,8 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_10() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
         modify();
         txn1.commit();
       }
@@ -105,8 +105,8 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_11() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
         modify();
         txn1.commit();
       }
@@ -118,9 +118,9 @@ public class TestNestedTransaction extends BaseTestCase {
   // ===== level 2 =======
   @Test
   public void testNested_000() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
-        try (Transaction txn2 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
+        try (Transaction txn2 = DB.beginTransaction()) {
           modify();
           // no commit
         }
@@ -133,9 +133,9 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_001() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
-        try (Transaction txn2 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
+        try (Transaction txn2 = DB.beginTransaction()) {
           modify();
           // no commit
         }
@@ -148,9 +148,9 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_010() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
-        try (Transaction txn2 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
+        try (Transaction txn2 = DB.beginTransaction()) {
           modify();
           // no commit
         }
@@ -163,9 +163,9 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_011() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
-        try (Transaction txn2 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
+        try (Transaction txn2 = DB.beginTransaction()) {
           modify();
           // no commit
         }
@@ -178,9 +178,9 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_100() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
-        try (Transaction txn2 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
+        try (Transaction txn2 = DB.beginTransaction()) {
           modify();
           txn2.commit();
         }
@@ -193,9 +193,9 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_101() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
-        try (Transaction txn2 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
+        try (Transaction txn2 = DB.beginTransaction()) {
           modify();
           txn2.commit();
         }
@@ -208,9 +208,9 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_110() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
-        try (Transaction txn2 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
+        try (Transaction txn2 = DB.beginTransaction()) {
           modify();
           txn2.commit();
         }
@@ -223,9 +223,9 @@ public class TestNestedTransaction extends BaseTestCase {
 
   @Test
   public void testNested_111() {
-    try (Transaction txn0 = Ebean.beginTransaction()) {
-      try (Transaction txn1 = Ebean.beginTransaction()) {
-        try (Transaction txn2 = Ebean.beginTransaction()) {
+    try (Transaction txn0 = DB.beginTransaction()) {
+      try (Transaction txn1 = DB.beginTransaction()) {
+        try (Transaction txn2 = DB.beginTransaction()) {
           modify();
           txn2.commit();
         }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestPersistContextClear.java b/ebean-test/src/test/java/org/tests/transaction/TestPersistContextClear.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/transaction/TestPersistContextClear.java
rename to ebean-test/src/test/java/org/tests/transaction/TestPersistContextClear.java
index 21a39af21..7b993e92d 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestPersistContextClear.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestPersistContextClear.java
@@ -1,19 +1,20 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.Transaction;
 import io.ebean.bean.PersistenceContext;
 import io.ebeaninternal.api.SpiTransaction;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.Order;
 import org.tests.model.basic.ResetBasicData;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestPersistContextClear extends BaseTestCase {
 
   @Test
@@ -23,31 +24,30 @@ public class TestPersistContextClear extends BaseTestCase {
 
     Order order0 = null;
 
-    Transaction t = Ebean.beginTransaction();
+    Transaction t = DB.beginTransaction();
     try {
       ResetBasicData.createOrderCustAndOrder("testPc");
       SpiTransaction spiTxn = (SpiTransaction) t;
       PersistenceContext pc = spiTxn.getPersistenceContext();
 
       // no orders or customers in the PC
-      Assert.assertEquals(0, pc.size(Order.class));
-      Assert.assertEquals(0, pc.size(Customer.class));
+      assertEquals(0, pc.size(Order.class));
+      assertEquals(0, pc.size(Customer.class));
 
-
-      EbeanServer server = Ebean.getServer(null);
+      Database server = DB.getDefault();
       List<Order> list = server.find(Order.class).fetch("customer").fetch("details").findList();
 
       int orderSize = list.size();
-      Assert.assertTrue(orderSize > 1);
+      assertTrue(orderSize > 1);
 
       // keep a hold of one of them
       order0 = list.get(0);
 
-      Assert.assertEquals(orderSize, pc.size(Order.class));
+      assertEquals(orderSize, pc.size(Order.class));
 
       System.gc();
-      Assert.assertEquals(orderSize, pc.size(Order.class));
-      Assert.assertTrue(pc.size(Customer.class) > 0);
+      assertEquals(orderSize, pc.size(Order.class));
+      assertTrue(pc.size(Customer.class) > 0);
 
       list = null;
       // System.gc();
@@ -55,8 +55,8 @@ public class TestPersistContextClear extends BaseTestCase {
       // transaction still holds PC ...
       // System.out.println("pc2:"+pc);
       // These asserts may not succeed depending on JVM
-      // Assert.assertEquals(pc.size(Order.class), 1);
-      // Assert.assertEquals(pc.size(Customer.class), 1);
+      // assertEquals(pc.size(Order.class), 1);
+      // assertEquals(pc.size(Customer.class), 1);
 
     } finally {
       t.end();
@@ -65,13 +65,13 @@ public class TestPersistContextClear extends BaseTestCase {
     System.gc();
 
     // we still have the order
-    Assert.assertNotNull(order0);
+    assertNotNull(order0);
     // its likely the only one in the PC now
     // due to the System.gc(); but can't garuntee it
     // so removing these asserts... can put them back
     // to manually test.
-    // Assert.assertEquals(pc.size(Order.class), 1);
-    // Assert.assertEquals(pc.size(Customer.class), 1);
+    // assertEquals(pc.size(Order.class), 1);
+    // assertEquals(pc.size(Customer.class), 1);
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestSavepoint.java b/ebean-test/src/test/java/org/tests/transaction/TestSavepoint.java
similarity index 71%
rename from ebean-core/src/test/java/org/tests/transaction/TestSavepoint.java
rename to ebean-test/src/test/java/org/tests/transaction/TestSavepoint.java
index 5a159b333..1ba7ffe01 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestSavepoint.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestSavepoint.java
@@ -1,11 +1,11 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 
 import java.sql.Connection;
@@ -22,21 +22,21 @@ public class TestSavepoint extends BaseTestCase {
 
     EBasicVer basicVer = new EBasicVer("save1");
     basicVer.setOther("other1");
-    Ebean.save(basicVer);
+    DB.save(basicVer);
 
-    try (Transaction transaction = Ebean.beginTransaction()) {
+    try (Transaction transaction = DB.beginTransaction()) {
 
-      Connection connection = transaction.getConnection();
+      Connection connection = transaction.connection();
       Savepoint savepoint = connection.setSavepoint();
 
       basicVer.setOther("changeOther");
-      Ebean.save(basicVer);
+      DB.save(basicVer);
 
       connection.rollback(savepoint);
       transaction.commit();
     }
 
-    EBasicVer found = Ebean.find(EBasicVer.class, basicVer.getId());
+    EBasicVer found = DB.find(EBasicVer.class, basicVer.getId());
     assertThat(found.getOther()).isEqualTo("other1");
 
   }
@@ -47,18 +47,18 @@ public class TestSavepoint extends BaseTestCase {
 
     EBasicVer basicVer = new EBasicVer("save2");
     basicVer.setOther("other2");
-    Ebean.save(basicVer);
+    DB.save(basicVer);
 
-    try (Transaction transaction = Ebean.beginTransaction()) {
+    try (Transaction transaction = DB.beginTransaction()) {
       transaction.setRollbackOnly();
 
       basicVer.setOther("changeOther");
-      Ebean.save(basicVer);
+      DB.save(basicVer);
 
       transaction.commit();
     }
 
-    EBasicVer found = Ebean.find(EBasicVer.class, basicVer.getId());
+    EBasicVer found = DB.find(EBasicVer.class, basicVer.getId());
     assertThat(found.getOther()).isEqualTo("other2");
 
   }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestSqlServerBatch.java b/ebean-test/src/test/java/org/tests/transaction/TestSqlServerBatch.java
similarity index 88%
rename from ebean-core/src/test/java/org/tests/transaction/TestSqlServerBatch.java
rename to ebean-test/src/test/java/org/tests/transaction/TestSqlServerBatch.java
index 019193413..18174625e 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestSqlServerBatch.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestSqlServerBatch.java
@@ -1,11 +1,11 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.ESimple;
 
 /**
@@ -22,7 +22,7 @@ public class TestSqlServerBatch extends BaseTestCase {
   @Test
   public void testBasicIdentityBatch() {
 
-    Transaction txn = Ebean.beginTransaction();
+    Transaction txn = DB.beginTransaction();
     try {
       txn.setBatchMode(true);
       txn.setBatchSize(3);
@@ -30,7 +30,7 @@ public class TestSqlServerBatch extends BaseTestCase {
       for (int i = 0; i < 10; i++) {
         ESimple model = new ESimple();
         model.setName("baz " + i);
-        Ebean.save(model);
+        DB.save(model);
       }
 
       txn.commit();
@@ -43,7 +43,7 @@ public class TestSqlServerBatch extends BaseTestCase {
   @Test
   public void testAggressiveBatch() {
 
-    Transaction txn = Ebean.beginTransaction();
+    Transaction txn = DB.beginTransaction();
     try {
       txn.setBatchMode(true);
       txn.setBatchSize(3);
@@ -61,7 +61,7 @@ public class TestSqlServerBatch extends BaseTestCase {
       for (int i = 0; i < 10; i++) {
         ESimple model = new ESimple();
         model.setName(i % 2 == 0 ? null : "foobar");
-        Ebean.save(model);
+        DB.save(model);
       }
 
       // do not commit
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestStatelessUpdateClearPC.java b/ebean-test/src/test/java/org/tests/transaction/TestStatelessUpdateClearPC.java
similarity index 60%
rename from ebean-core/src/test/java/org/tests/transaction/TestStatelessUpdateClearPC.java
rename to ebean-test/src/test/java/org/tests/transaction/TestStatelessUpdateClearPC.java
index bb2222038..946fcda03 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestStatelessUpdateClearPC.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestStatelessUpdateClearPC.java
@@ -1,12 +1,12 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
-import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 public class TestStatelessUpdateClearPC extends BaseTestCase {
 
@@ -14,26 +14,26 @@ public class TestStatelessUpdateClearPC extends BaseTestCase {
   public void test() {
 
 
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
       EBasic newUser = new EBasic();
       newUser.setName("any@email.com");
-      Ebean.save(newUser);
+      DB.save(newUser);
 
       // load the bean into the persistence context
-      EBasic dummyLoadedUser = Ebean.find(EBasic.class, newUser.getId()); // This row is added
+      EBasic dummyLoadedUser = DB.find(EBasic.class, newUser.getId()); // This row is added
       assertNotNull(dummyLoadedUser);
 
       // stateless update (should clear the bean from the persistence context)
       EBasic updateUser = new EBasic();
       updateUser.setId(newUser.getId());
       updateUser.setName("anyNew@email.com");
-      Ebean.update(updateUser);
+      DB.update(updateUser);
 
-      EBasic loadedUser = Ebean.find(EBasic.class, newUser.getId());
+      EBasic loadedUser = DB.find(EBasic.class, newUser.getId());
       assertEquals("anyNew@email.com", loadedUser.getName());
     } finally {
-      Ebean.rollbackTransaction();
+      DB.rollbackTransaction();
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionCallback.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionCallback.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionCallback.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionCallback.java
index d926b8067..3135fa42f 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionCallback.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionCallback.java
@@ -4,11 +4,12 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.TransactionCallbackAdapter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import javax.persistence.PersistenceException;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class TestTransactionCallback extends BaseTestCase {
 
@@ -21,7 +22,7 @@ public class TestTransactionCallback extends BaseTestCase {
   public void test_commitAndRollback() {
     try (Transaction txn = DB.beginTransaction()) {
       DB.register(new MyCallback());
-      txn.getConnection(); // Ebean assumes writes have occurred
+      txn.connection(); // Ebean assumes writes have occurred
       txn.commit();
     }
 
@@ -69,14 +70,14 @@ public class TestTransactionCallback extends BaseTestCase {
     assertEquals(1, countPostRollback);
   }
 
-  @Test(expected = PersistenceException.class)
+  @Test
   public void test_noActiveTransaction() {
-    DB.register(new MyCallback());
+    assertThrows(PersistenceException.class, () -> DB.register(new MyCallback()));
   }
 
-  @Test(expected = PersistenceException.class)
+  @Test
   public void test_noActiveTransaction_withDatabase() {
-    DB.getDefault().register(new MyCallback());
+    assertThrows(PersistenceException.class, () -> DB.getDefault().register(new MyCallback()));
   }
 
   class MyCallback extends TransactionCallbackAdapter {
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionRollbackOnly.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionRollbackOnly.java
similarity index 72%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionRollbackOnly.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionRollbackOnly.java
index 787fb7653..dc426cf36 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionRollbackOnly.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionRollbackOnly.java
@@ -1,14 +1,14 @@
 package org.tests.transaction;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.Transactional;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestTransactionRollbackOnly {
 
@@ -22,14 +22,14 @@ public class TestTransactionRollbackOnly {
     doVia_currentTransaction();
 
     assertThat(one.getId()).isNotNull();
-    assertThat(Ebean.find(EBasic.class, one.getId())).isNull();
+    assertThat(DB.find(EBasic.class, one.getId())).isNull();
   }
 
   @Transactional
   protected void doVia_currentTransaction() {
 
     one = new EBasic("WillNotSave");
-    Ebean.save(one);
+    DB.save(one);
 
     Transaction transaction = Transaction.current();
     assertFalse(transaction.isRollbackOnly());
@@ -44,15 +44,15 @@ public class TestTransactionRollbackOnly {
     do_Ebean_setRollbackOnly();
 
     assertThat(two.getId()).isNotNull();
-    assertThat(Ebean.find(EBasic.class, two.getId())).isNull();
+    assertThat(DB.find(EBasic.class, two.getId())).isNull();
   }
 
   @Transactional
   protected void do_Ebean_setRollbackOnly() {
 
     two = new EBasic("WillNotSave");
-    Ebean.save(two);
+    DB.save(two);
 
-    Ebean.setRollbackOnly();
+    DB.setRollbackOnly();
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionSkipCache.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionSkipCache.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionSkipCache.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionSkipCache.java
index d02424c9d..fab0b3eb3 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionSkipCache.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionSkipCache.java
@@ -2,10 +2,10 @@ package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
 import io.ebean.CacheMode;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.ResetBasicData;
 
@@ -17,7 +17,7 @@ public class TestTransactionSkipCache extends BaseTestCase {
 
   private void findUseQueryCache() {
 
-    Ebean.find(Customer.class)
+    DB.find(Customer.class)
       .setUseQueryCache(true)
       .setBeanCacheMode(CacheMode.PUT)
       .where().startsWith("name", "Rob")
@@ -35,14 +35,14 @@ public class TestTransactionSkipCache extends BaseTestCase {
 
     setup();
 
-    Transaction transaction = Ebean.beginTransaction();
+    Transaction transaction = DB.beginTransaction();
     try {
       transaction.setSkipCache(true);
 
-      LoggedSqlCollector.start();
+      LoggedSql.start();
       findUseQueryCache();
 
-      List<String> sql = LoggedSqlCollector.stop();
+      List<String> sql = LoggedSql.stop();
       assertThat(sql).as("We didn't use the L2 query cache").hasSize(1);
 
     } finally {
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionTryResources.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionTryResources.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionTryResources.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionTryResources.java
index f53640dfd..e2511c543 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionTryResources.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionTryResources.java
@@ -1,12 +1,12 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
+import io.ebean.DB;
 import io.ebean.DuplicateKeyException;
-import io.ebean.Ebean;
 import io.ebean.Transaction;
 import io.ebean.annotation.IgnorePlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.draftable.Document;
@@ -24,7 +24,7 @@ public class TestTransactionTryResources extends BaseTestCase {
 
     Document doc = new Document();
 
-    try (Transaction transaction = Ebean.beginTransaction()) {
+    try (Transaction transaction = DB.beginTransaction()) {
 
       doc.setTitle("tryWithResources");
       doc.setBody("stuff");
@@ -37,14 +37,14 @@ public class TestTransactionTryResources extends BaseTestCase {
     assertThat(document.isDraft()).isTrue();
 
     // cleanup
-    Ebean.delete(document);
+    DB.delete(document);
   }
 
   @Test
   @IgnorePlatform(Platform.ORACLE) // does not support uncommited reads
   public void tryWithResources_catch() {
     Document doc = null;
-    try (Transaction transaction = Ebean.beginTransaction()) {
+    try (Transaction transaction = DB.beginTransaction()) {
 
       doc = new Document();
       doc.setTitle("tryWithResources_catch");
@@ -75,8 +75,8 @@ public class TestTransactionTryResources extends BaseTestCase {
       assertThat(docs).hasSize(1);
       assertThat(doc).isNotNull();
       // Cleanup
-      Ebean.delete(Document.class, doc.getId());
-      Ebean.delete(Document.class, doc3.getId());
+      DB.delete(Document.class, doc.getId());
+      DB.delete(Document.class, doc3.getId());
     }
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalNever.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalNever.java
similarity index 78%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionalNever.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionalNever.java
index e62aaae19..f6bf776a8 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalNever.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalNever.java
@@ -1,16 +1,18 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.Transactional;
 import io.ebean.annotation.TxType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.persistence.PersistenceException;
 
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 public class TestTransactionalNever extends BaseTestCase {
 
   private static final Logger log = LoggerFactory.getLogger(TestTransactionalNever.class);
@@ -23,16 +25,16 @@ public class TestTransactionalNever extends BaseTestCase {
     new SomeTransactionalWithNever().doStuff();
   }
 
-  @Test(expected = PersistenceException.class)
+  @Test
   public void testBarfOnExisting() {
-    doWithTransaction();
+    assertThrows(PersistenceException.class, this::doWithTransaction);
   }
 
   class SomeTransactionalWithNever {
 
     @Transactional(type = TxType.NEVER)
     void doStuff() {
-      outerTxn = Ebean.currentTransaction();
+      outerTxn = DB.currentTransaction();
       log.info("currentTransaction ...{}", outerTxn);
     }
   }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalNotSupports.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalNotSupports.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionalNotSupports.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionalNotSupports.java
index a13e73022..b530252f8 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalNotSupports.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalNotSupports.java
@@ -1,17 +1,15 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.Transactional;
 import io.ebean.annotation.TxType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestTransactionalNotSupports extends BaseTestCase {
 
@@ -34,9 +32,9 @@ public class TestTransactionalNotSupports extends BaseTestCase {
   public void withOuterTransaction_expect_currentTransaction_null_and_originalTxnRestored() {
 
     outerTxn = null;
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
-      currentTxn = Ebean.currentTransaction();
+      currentTxn = DB.currentTransaction();
       assertNotNull(currentTxn);
       new SomeTransactionalWithNotSupported().doStuff();
 
@@ -44,10 +42,10 @@ public class TestTransactionalNotSupports extends BaseTestCase {
       assertNull(outerTxn);
 
       // the original transaction was restored
-      Transaction restored = Ebean.currentTransaction();
+      Transaction restored = DB.currentTransaction();
       assertSame(currentTxn, restored);
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
   }
 
@@ -55,7 +53,7 @@ public class TestTransactionalNotSupports extends BaseTestCase {
 
     @Transactional(type = TxType.NOT_SUPPORTED)
     void doStuff() {
-      outerTxn = Ebean.currentTransaction();
+      outerTxn = DB.currentTransaction();
       log.info("outer ...{}", outerTxn);
     }
   }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalReadOnly.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalReadOnly.java
similarity index 97%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionalReadOnly.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionalReadOnly.java
index 28e0be699..2c8156ccb 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalReadOnly.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalReadOnly.java
@@ -4,7 +4,7 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.annotation.Transactional;
 import io.ebean.meta.MetaTimedMetric;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import java.util.List;
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalRequired.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalRequired.java
similarity index 70%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionalRequired.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionalRequired.java
index be62f7d66..a3c367dc3 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalRequired.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalRequired.java
@@ -1,17 +1,15 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.Transactional;
 import io.ebean.annotation.TxType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestTransactionalRequired extends BaseTestCase {
 
@@ -26,11 +24,11 @@ public class TestTransactionalRequired extends BaseTestCase {
 
     outerTxn = null;
 
-    assertNull(Ebean.currentTransaction());
+    assertNull(DB.currentTransaction());
 
     new OuterTransactionalWithRequired().doOuter();
 
-    assertNull(Ebean.currentTransaction());
+    assertNull(DB.currentTransaction());
 
     assertNotNull(outerTxn);
     assertNotNull(innerTxn);
@@ -42,34 +40,34 @@ public class TestTransactionalRequired extends BaseTestCase {
   public void withOuterBegin() {
 
     outerTxn = null;
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
-      currentTxn = Ebean.currentTransaction();
+      currentTxn = DB.currentTransaction();
       assertNotNull(currentTxn);
       new OuterTransactionalWithRequired().doOuter();
 
       // the original transaction was restored
-      Transaction restored = Ebean.currentTransaction();
+      Transaction restored = DB.currentTransaction();
       assertSame(currentTxn, restored);
       assertSame(currentTxn, innerTxn);
       assertSame(currentTxn, outerTxn);
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
 
-    assertNull(Ebean.currentTransaction());
+    assertNull(DB.currentTransaction());
   }
 
   class OuterTransactionalWithRequired {
 
     @Transactional(type = TxType.REQUIRED)
     void doOuter() {
-      outerTxn = Ebean.currentTransaction();
+      outerTxn = DB.currentTransaction();
       log.info("outer ...{}", outerTxn);
 
       new InTransactionalWithRequired().doInner();
 
-      Transaction current = Ebean.currentTransaction();
+      Transaction current = DB.currentTransaction();
       assertSame(outerTxn, current);
     }
 
@@ -79,7 +77,7 @@ public class TestTransactionalRequired extends BaseTestCase {
 
     @Transactional(type = TxType.REQUIRED)
     void doInner() {
-      innerTxn = Ebean.currentTransaction();
+      innerTxn = DB.currentTransaction();
       log.info("inner ...{}", innerTxn);
     }
   }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalRequiresNew.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalRequiresNew.java
similarity index 69%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionalRequiresNew.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionalRequiresNew.java
index 7e0415575..3e38e2d0c 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalRequiresNew.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalRequiresNew.java
@@ -1,23 +1,16 @@
 package org.tests.transaction;
 
-import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
-import io.ebean.Transaction;
-import io.ebean.TxScope;
+import io.ebean.*;
 import io.ebean.annotation.Transactional;
 import io.ebean.annotation.TxType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.sql.Connection;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestTransactionalRequiresNew extends BaseTestCase {
 
@@ -30,11 +23,11 @@ public class TestTransactionalRequiresNew extends BaseTestCase {
   public void basic() {
 
     outerTxn = null;
-    assertNull(Ebean.currentTransaction());
+    assertNull(DB.currentTransaction());
 
     new OuterTransactionalWithRequired().doOuter();
 
-    assertNull(Ebean.currentTransaction());
+    assertNull(DB.currentTransaction());
     assertNotNull(outerTxn);
   }
 
@@ -43,16 +36,16 @@ public class TestTransactionalRequiresNew extends BaseTestCase {
 
     @Transactional
     void doOuter() {
-      outerTxn = Ebean.currentTransaction();
+      outerTxn = DB.currentTransaction();
       log.info("outer before ...{}", outerTxn);
-      outerConn = outerTxn.getConnection();
+      outerConn = outerTxn.connection();
 
       new InTransactionalWithRequiresNew().doInner();
 
       // restore the outerTxn
-      Transaction current = Ebean.currentTransaction();
+      Transaction current = DB.currentTransaction();
       log.info("outer after ...{}", current);
-      assertSame(outerConn, current.getConnection());
+      assertSame(outerConn, current.connection());
     }
 
   }
@@ -61,24 +54,24 @@ public class TestTransactionalRequiresNew extends BaseTestCase {
 
     @Transactional(type = TxType.REQUIRES_NEW)
     void doInner() {
-      Transaction innerTxn = Ebean.currentTransaction();
+      Transaction innerTxn = DB.currentTransaction();
       log.info("inner ...{} {}", innerTxn);
 
-      Connection connection = innerTxn.getConnection();
+      Connection connection = innerTxn.connection();
       assertNotSame(connection, outerConn);
     }
   }
 
   @Test
   public void testDifferentCreation1() {
-    EbeanServer server = server();
+    Database server = server();
     try(Transaction txn = server.beginTransaction()) {
       String txnName = txn.toString();
-      Ebean.beginTransaction(TxScope.requiresNew());
+      DB.beginTransaction(TxScope.requiresNew());
       try {
-        Ebean.commitTransaction();
+        DB.commitTransaction();
       } finally {
-        Ebean.endTransaction();
+        DB.endTransaction();
       }
       assertThat(txn.toString()).isEqualTo(txnName);
     }
@@ -86,7 +79,7 @@ public class TestTransactionalRequiresNew extends BaseTestCase {
 
   @Test
   public void testDifferentCreation2() {
-    EbeanServer server = server();
+    Database server = server();
     try (Transaction txn = server.beginTransaction()) {
       String txnName = txn.toString();
       server.beginTransaction(TxScope.requiresNew());
@@ -101,10 +94,10 @@ public class TestTransactionalRequiresNew extends BaseTestCase {
 
   @Test
   public void testDifferentCreation3() {
-    EbeanServer server = server();
+    Database server = server();
     try (Transaction txn = server.beginTransaction()) {
       String txnName = txn.toString();
-      Transaction txn2 = Ebean.beginTransaction(TxScope.requiresNew());
+      Transaction txn2 = DB.beginTransaction(TxScope.requiresNew());
       try {
         txn2.commit();
       } finally {
@@ -116,7 +109,7 @@ public class TestTransactionalRequiresNew extends BaseTestCase {
 
   @Test
   public void testDifferentCreation4() {
-    EbeanServer server = server();
+    Database server = server();
     try (Transaction txn = server.beginTransaction()) {
       String txnName = txn.toString();
       server.beginTransaction(TxScope.requiresNew());
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalSupports.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalSupports.java
similarity index 83%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionalSupports.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionalSupports.java
index a67812243..53b55b6bb 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalSupports.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalSupports.java
@@ -1,18 +1,18 @@
 package org.tests.transaction;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
 import io.ebean.annotation.Transactional;
 import io.ebean.annotation.TxType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.EBasic;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestTransactionalSupports extends BaseTestCase {
 
@@ -33,12 +33,12 @@ public class TestTransactionalSupports extends BaseTestCase {
   public void withOuterTransaction_expect_currentTransactionAvailable() {
 
     outerTxn = null;
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
       new SomeTransactionalWithSupports().doStuff();
       assertNotNull(outerTxn);
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
   }
 
@@ -53,7 +53,7 @@ public class TestTransactionalSupports extends BaseTestCase {
 
     @Transactional(type = TxType.SUPPORTS)
     void doStuff() {
-      outerTxn = Ebean.currentTransaction();
+      outerTxn = DB.currentTransaction();
       log.info("outer ...{}", outerTxn);
     }
   }
@@ -68,7 +68,7 @@ public class TestTransactionalSupports extends BaseTestCase {
       basic.setName("checkSupports");
 
       // effective creates a transaction replacing the 'No active transaction' placeholder
-      Ebean.save(basic);
+      DB.save(basic);
 
       return 42;
     }
diff --git a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalWhenThrow.java b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalWhenThrow.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/transaction/TestTransactionalWhenThrow.java
rename to ebean-test/src/test/java/org/tests/transaction/TestTransactionalWhenThrow.java
index 057f76ada..0cbbba720 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TestTransactionalWhenThrow.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TestTransactionalWhenThrow.java
@@ -2,7 +2,7 @@ package org.tests.transaction;
 
 import io.ebean.DB;
 import io.ebean.annotation.Transactional;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.tests.model.basic.EBasicVer;
diff --git a/ebean-core/src/test/java/org/tests/transaction/TransactionNotTerminatedAfterRollback.java b/ebean-test/src/test/java/org/tests/transaction/TransactionNotTerminatedAfterRollback.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/transaction/TransactionNotTerminatedAfterRollback.java
rename to ebean-test/src/test/java/org/tests/transaction/TransactionNotTerminatedAfterRollback.java
index eb693ca48..3a2d3e83d 100644
--- a/ebean-core/src/test/java/org/tests/transaction/TransactionNotTerminatedAfterRollback.java
+++ b/ebean-test/src/test/java/org/tests/transaction/TransactionNotTerminatedAfterRollback.java
@@ -1,8 +1,8 @@
 package org.tests.transaction;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.annotation.Transactional;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -12,8 +12,8 @@ import javax.persistence.PersistenceException;
 import javax.persistence.Table;
 import java.util.List;
 
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
 
 /**
  * It shows the issue that the user record does NOT rolback when there is an exception thrown
@@ -29,16 +29,16 @@ public class TransactionNotTerminatedAfterRollback {
     } catch (PersistenceException pe) {
       LOG.error("e: " + pe);
     }
-    List<User> users = Ebean.find(User.class).findList();
+    List<User> users = DB.find(User.class).findList();
     LOG.debug("users: {}", users);
-    assertTrue("users should be empty", users.isEmpty());
+    assertThat(users).isEmpty();
   }
 
   @Transactional(rollbackFor = PersistenceException.class)
   public class UserService {
     public void create(User i) {
-      Ebean.save(i);
-      Ebean.save(new User(1L, "Peter")); // make it throw exception and rollback
+      DB.save(i);
+      DB.save(new User(1L, "Peter")); // make it throw exception and rollback
     }
   }
 
diff --git a/ebean-core/src/test/java/org/tests/transparentpersist/TestTransparentPersist.java b/ebean-test/src/test/java/org/tests/transparentpersist/TestTransparentPersist.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/transparentpersist/TestTransparentPersist.java
rename to ebean-test/src/test/java/org/tests/transparentpersist/TestTransparentPersist.java
index 8a870f8ab..ed0cfb175 100644
--- a/ebean-core/src/test/java/org/tests/transparentpersist/TestTransparentPersist.java
+++ b/ebean-test/src/test/java/org/tests/transparentpersist/TestTransparentPersist.java
@@ -1,11 +1,12 @@
 package org.tests.transparentpersist;
 
 import io.ebean.*;
-import io.ebean.annotation.*;
+import io.ebean.annotation.Transactional;
+import io.ebean.annotation.TxOption;
+import io.ebean.test.LoggedSql;
 import io.ebeaninternal.api.SpiBeanTypeManager;
 import io.ebeaninternal.api.SpiTransaction;
-import io.ebeantest.LoggedSql;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasicVer;
diff --git a/ebean-core/src/test/java/org/tests/types/EncryptedBinary.java b/ebean-test/src/test/java/org/tests/types/EncryptedBinary.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/types/EncryptedBinary.java
rename to ebean-test/src/test/java/org/tests/types/EncryptedBinary.java
diff --git a/ebean-core/src/test/java/org/tests/types/EncryptedString.java b/ebean-test/src/test/java/org/tests/types/EncryptedString.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/types/EncryptedString.java
rename to ebean-test/src/test/java/org/tests/types/EncryptedString.java
diff --git a/ebean-core/src/test/java/org/tests/types/PasswordStoreModel.java b/ebean-test/src/test/java/org/tests/types/PasswordStoreModel.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/types/PasswordStoreModel.java
rename to ebean-test/src/test/java/org/tests/types/PasswordStoreModel.java
index 07578ed6c..904ae2350 100644
--- a/ebean-core/src/test/java/org/tests/types/PasswordStoreModel.java
+++ b/ebean-test/src/test/java/org/tests/types/PasswordStoreModel.java
@@ -1,12 +1,12 @@
 package org.tests.types;
 
+import org.tests.model.BaseModel;
+
 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.Lob;
 import javax.validation.constraints.Size;
 
-import org.tests.model.BaseModel;
-
 @Entity
 public class PasswordStoreModel extends BaseModel {
   private static final long serialVersionUID = 1L;
diff --git a/ebean-core/src/test/java/org/tests/types/ScalarTypeEncryptedBinaryConverter.java b/ebean-test/src/test/java/org/tests/types/ScalarTypeEncryptedBinaryConverter.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/types/ScalarTypeEncryptedBinaryConverter.java
rename to ebean-test/src/test/java/org/tests/types/ScalarTypeEncryptedBinaryConverter.java
diff --git a/ebean-core/src/test/java/org/tests/types/ScalarTypeEncryptedStringConverter.java b/ebean-test/src/test/java/org/tests/types/ScalarTypeEncryptedStringConverter.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/types/ScalarTypeEncryptedStringConverter.java
rename to ebean-test/src/test/java/org/tests/types/ScalarTypeEncryptedStringConverter.java
diff --git a/ebean-core/src/test/java/org/tests/types/TestEncryptedString.java b/ebean-test/src/test/java/org/tests/types/TestEncryptedString.java
similarity index 93%
rename from ebean-core/src/test/java/org/tests/types/TestEncryptedString.java
rename to ebean-test/src/test/java/org/tests/types/TestEncryptedString.java
index 3f510b4b3..4fdeaea07 100644
--- a/ebean-core/src/test/java/org/tests/types/TestEncryptedString.java
+++ b/ebean-test/src/test/java/org/tests/types/TestEncryptedString.java
@@ -1,8 +1,8 @@
 package org.tests.types;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 
 import java.nio.charset.StandardCharsets;
 
@@ -25,7 +25,7 @@ public class TestEncryptedString extends BaseTestCase {
 
     model.save();
 
-    model = Ebean.find(PasswordStoreModel.class, model.getId());
+    model = DB.find(PasswordStoreModel.class, model.getId());
 
     assertThat(model.getEnc1().getEncryptedData()).isNotEqualTo("Hello");
     assertThat(model.getEnc2().getEncryptedData()).isNotEqualTo("World");
diff --git a/ebean-core/src/test/java/org/tests/types/TestFileType.java b/ebean-test/src/test/java/org/tests/types/TestFileType.java
similarity index 79%
rename from ebean-core/src/test/java/org/tests/types/TestFileType.java
rename to ebean-test/src/test/java/org/tests/types/TestFileType.java
index 85d3d2173..39dc9e528 100644
--- a/ebean-core/src/test/java/org/tests/types/TestFileType.java
+++ b/ebean-test/src/test/java/org/tests/types/TestFileType.java
@@ -1,9 +1,9 @@
 package org.tests.types;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.types.SomeFileBean;
 
 import java.io.File;
@@ -11,10 +11,7 @@ import java.io.IOException;
 import java.io.PrintStream;
 import java.net.URL;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestFileType extends BaseTestCase {
 
@@ -37,7 +34,7 @@ public class TestFileType extends BaseTestCase {
     SomeFileBean bean0 = new SomeFileBean();
     bean0.setName("tempBeanUnbatched");
     bean0.setContent(tempFile);
-    Ebean.save(bean0);
+    DB.save(bean0);
 
     assertTrue(tempFile.delete());
   }
@@ -48,13 +45,13 @@ public class TestFileType extends BaseTestCase {
     SomeFileBean bean0 = new SomeFileBean();
     bean0.setName("tempBeanUnbatched");
     bean0.setContent(newTempFile());
-    Ebean.save(bean0);
+    DB.save(bean0);
 
 
     File updateFile = newTempFile();
     bean0.setName("tempBeanModified");
     bean0.setContent(updateFile);
-    Ebean.save(bean0);
+    DB.save(bean0);
 
     assertTrue(updateFile.delete());
   }
@@ -65,18 +62,18 @@ public class TestFileType extends BaseTestCase {
     SomeFileBean bean0 = new SomeFileBean();
     bean0.setName("tempBeanUnbatched");
     bean0.setContent(newTempFile());
-    Ebean.save(bean0);
+    DB.save(bean0);
 
 
     File tempFile = newTempFile();
 
-    try (Transaction txn = Ebean.beginTransaction()) {
+    try (Transaction txn = DB.beginTransaction()) {
       txn.setBatchSize(30);
       txn.setBatchMode(true);
 
       bean0.setName("tempBeanBatchedModified");
       bean0.setContent(tempFile);
-      Ebean.save(bean0);
+      DB.save(bean0);
 
       txn.commit();
     }
@@ -89,14 +86,14 @@ public class TestFileType extends BaseTestCase {
 
     File tempFile = newTempFile();
 
-    try (Transaction txn = Ebean.beginTransaction()) {
+    try (Transaction txn = DB.beginTransaction()) {
       txn.setBatchSize(30);
       txn.setBatchMode(true);
 
       SomeFileBean bean0 = new SomeFileBean();
       bean0.setName("tempBeanBatched");
       bean0.setContent(tempFile);
-      Ebean.save(bean0);
+      DB.save(bean0);
 
       txn.commit();
     }
@@ -112,9 +109,9 @@ public class TestFileType extends BaseTestCase {
 
     SomeFileBean bean0 = new SomeFileBean();
     bean0.setName("afile");
-    Ebean.save(bean0);
+    DB.save(bean0);
 
-    SomeFileBean bean1 = Ebean.find(SomeFileBean.class)
+    SomeFileBean bean1 = DB.find(SomeFileBean.class)
       .select("name, file")
       .setId(bean0.getId())
       .findOne();
@@ -123,16 +120,16 @@ public class TestFileType extends BaseTestCase {
     assertNull(bean1.getContent());
 
     bean1.setContent(file);
-    Ebean.save(bean1);
+    DB.save(bean1);
 
-    SomeFileBean bean2 = Ebean.find(SomeFileBean.class)
+    SomeFileBean bean2 = DB.find(SomeFileBean.class)
       .select("name, file")
       .setId(bean0.getId())
       .findOne();
 
     assertEquals("afile", bean2.getName());
     assertNotNull(bean2.getContent());
-    Ebean.delete(bean1);
+    DB.delete(bean1);
   }
 
   @Test
@@ -145,9 +142,9 @@ public class TestFileType extends BaseTestCase {
     bean0.setName("afile");
     bean0.setContent(file);
 
-    Ebean.save(bean0);
+    DB.save(bean0);
 
-    SomeFileBean bean1 = Ebean.find(SomeFileBean.class)
+    SomeFileBean bean1 = DB.find(SomeFileBean.class)
       .select("name, file")
       .setId(bean0.getId())
       .findOne();
@@ -159,10 +156,10 @@ public class TestFileType extends BaseTestCase {
     bean1.setName("mod-file");
     bean1.setContent(file2);
     // update to file2
-    Ebean.save(bean1);
+    DB.save(bean1);
 
 
-    SomeFileBean bean2 = Ebean.find(SomeFileBean.class)
+    SomeFileBean bean2 = DB.find(SomeFileBean.class)
       .select("name, file")
       .setId(bean0.getId())
       .findOne();
@@ -172,9 +169,9 @@ public class TestFileType extends BaseTestCase {
     // update to null
     bean2.setContent(null);
     bean2.setName("setNull");
-    Ebean.save(bean2);
+    DB.save(bean2);
 
-    SomeFileBean bean3 = Ebean.find(SomeFileBean.class)
+    SomeFileBean bean3 = DB.find(SomeFileBean.class)
       .select("name, file")
       .setId(bean0.getId())
       .findOne();
@@ -182,9 +179,9 @@ public class TestFileType extends BaseTestCase {
     assertNull(bean3.getContent());
 
     bean3.setName("changeOnlyName");
-    Ebean.save(bean3);
+    DB.save(bean3);
 
-    Ebean.delete(bean3);
+    DB.delete(bean3);
   }
 
   private File getFile(String resource) {
diff --git a/ebean-core/src/test/java/org/tests/types/TestFileTypeFetching.java b/ebean-test/src/test/java/org/tests/types/TestFileTypeFetching.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/types/TestFileTypeFetching.java
rename to ebean-test/src/test/java/org/tests/types/TestFileTypeFetching.java
index 365c4ae91..6518e2919 100644
--- a/ebean-core/src/test/java/org/tests/types/TestFileTypeFetching.java
+++ b/ebean-test/src/test/java/org/tests/types/TestFileTypeFetching.java
@@ -2,15 +2,15 @@ package org.tests.types;
 
 import io.ebean.BaseTestCase;
 import io.ebean.BeanState;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.types.SomeFileBean;
-import org.junit.Test;
 
 import java.io.File;
 import java.net.URL;
 import java.util.Set;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestFileTypeFetching extends BaseTestCase {
 
@@ -25,14 +25,14 @@ public class TestFileTypeFetching extends BaseTestCase {
     SomeFileBean bean0 = new SomeFileBean();
     bean0.setName("one");
     bean0.setContent(file);
-    Ebean.save(bean0);
+    DB.save(bean0);
 
-    SomeFileBean bean1 = Ebean.find(SomeFileBean.class)
+    SomeFileBean bean1 = DB.find(SomeFileBean.class)
       .setId(bean0.getId())
       .findOne();
 
-    BeanState beanState = Ebean.getBeanState(bean1);
-    Set<String> loadedProps = beanState.getLoadedProps();
+    BeanState beanState = DB.beanState(bean1);
+    Set<String> loadedProps = beanState.loadedProps();
     assertTrue(loadedProps.contains("name"));
     assertFalse(loadedProps.contains("content"));
 
@@ -45,16 +45,16 @@ public class TestFileTypeFetching extends BaseTestCase {
     statelessUpdateBean.setContent(file2);
 
     // perform stateless update (handy)
-    Ebean.update(statelessUpdateBean);
+    DB.update(statelessUpdateBean);
 
-    SomeFileBean bean2 = Ebean.find(SomeFileBean.class)
+    SomeFileBean bean2 = DB.find(SomeFileBean.class)
       .select("file")
       .setId(bean0.getId())
       .findOne();
 
     assertEquals(file2.length(), bean2.getContent().length());
 
-    Ebean.delete(bean1);
+    DB.delete(bean1);
   }
 
   private File getFile(String resource) {
diff --git a/ebean-core/src/test/java/org/tests/types/TestHstore.java b/ebean-test/src/test/java/org/tests/types/TestHstore.java
similarity index 84%
rename from ebean-core/src/test/java/org/tests/types/TestHstore.java
rename to ebean-test/src/test/java/org/tests/types/TestHstore.java
index 946f256f4..e852a6955 100644
--- a/ebean-core/src/test/java/org/tests/types/TestHstore.java
+++ b/ebean-test/src/test/java/org/tests/types/TestHstore.java
@@ -2,17 +2,15 @@ package org.tests.types;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.annotation.ForPlatform;
-import io.ebean.annotation.Platform;
-import org.tests.model.json.EBasicHstore;
+import io.ebean.test.LoggedSql;
 import org.assertj.core.api.Assertions;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.tests.model.json.EBasicHstore;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestHstore extends BaseTestCase {
 
@@ -52,9 +50,9 @@ public class TestHstore extends BaseTestCase {
     EBasicHstore found = DB.find(EBasicHstore.class, bean.getId());
     found.setName("modName");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.save(found);
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     // we don't update the map as it is not dirty
     assertSql(sql.get(0)).contains("update ebasic_hstore set name=?, version=? where");
@@ -66,9 +64,9 @@ public class TestHstore extends BaseTestCase {
     found.setName("modNamePlus");
     found.getMap().put("foo", "9987");
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
     DB.save(found);
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
 
     assertSql(sql.get(0)).contains("update ebasic_hstore set name=?, map=?, version=? where id=? and version=?");
   }
diff --git a/ebean-core/src/test/java/org/tests/types/TestNewTypes.java b/ebean-test/src/test/java/org/tests/types/TestNewTypes.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/types/TestNewTypes.java
rename to ebean-test/src/test/java/org/tests/types/TestNewTypes.java
index ca02e91bc..35732801e 100644
--- a/ebean-core/src/test/java/org/tests/types/TestNewTypes.java
+++ b/ebean-test/src/test/java/org/tests/types/TestNewTypes.java
@@ -4,31 +4,17 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.plugin.BeanType;
 import io.ebean.plugin.ExpressionPath;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.types.SomeNewTypesBean;
 
 import java.io.File;
 import java.nio.file.Paths;
-import java.time.DayOfWeek;
-import java.time.Duration;
-import java.time.Instant;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.LocalTime;
-import java.time.Month;
-import java.time.MonthDay;
-import java.time.OffsetDateTime;
-import java.time.Period;
-import java.time.Year;
-import java.time.YearMonth;
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
+import java.time.*;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestNewTypes extends BaseTestCase {
 
@@ -216,23 +202,23 @@ public class TestNewTypes extends BaseTestCase {
 
   private void testSetGetPath(SomeNewTypesBean refBean) {
     SomeNewTypesBean testBean = new SomeNewTypesBean();
-    BeanType<SomeNewTypesBean> beanType = DB.getDefault().getPluginApi().getBeanType(SomeNewTypesBean.class);
-    ExpressionPath localDate = beanType.getExpressionPath("localDate");
-    ExpressionPath localDateTime = beanType.getExpressionPath("localDateTime");
-    ExpressionPath offsetDateTime = beanType.getExpressionPath("offsetDateTime");
-    ExpressionPath zonedDateTime = beanType.getExpressionPath("zonedDateTime");
-    ExpressionPath localTime = beanType.getExpressionPath("localTime");
-    ExpressionPath instant = beanType.getExpressionPath("instant");
-    ExpressionPath year = beanType.getExpressionPath("year");
-    ExpressionPath month = beanType.getExpressionPath("month");
-    ExpressionPath dayOfWeek = beanType.getExpressionPath("dayOfWeek");
-    ExpressionPath zoneId = beanType.getExpressionPath("zoneId");
-    ExpressionPath zoneOffset = beanType.getExpressionPath("zoneOffset");
-    ExpressionPath yearMonth = beanType.getExpressionPath("yearMonth");
-    ExpressionPath monthDay = beanType.getExpressionPath("monthDay");
-    ExpressionPath path = beanType.getExpressionPath("path");
-    ExpressionPath period = beanType.getExpressionPath("period");
-    ExpressionPath duration = beanType.getExpressionPath("duration");
+    BeanType<SomeNewTypesBean> beanType = DB.getDefault().pluginApi().beanType(SomeNewTypesBean.class);
+    ExpressionPath localDate = beanType.expressionPath("localDate");
+    ExpressionPath localDateTime = beanType.expressionPath("localDateTime");
+    ExpressionPath offsetDateTime = beanType.expressionPath("offsetDateTime");
+    ExpressionPath zonedDateTime = beanType.expressionPath("zonedDateTime");
+    ExpressionPath localTime = beanType.expressionPath("localTime");
+    ExpressionPath instant = beanType.expressionPath("instant");
+    ExpressionPath year = beanType.expressionPath("year");
+    ExpressionPath month = beanType.expressionPath("month");
+    ExpressionPath dayOfWeek = beanType.expressionPath("dayOfWeek");
+    ExpressionPath zoneId = beanType.expressionPath("zoneId");
+    ExpressionPath zoneOffset = beanType.expressionPath("zoneOffset");
+    ExpressionPath yearMonth = beanType.expressionPath("yearMonth");
+    ExpressionPath monthDay = beanType.expressionPath("monthDay");
+    ExpressionPath path = beanType.expressionPath("path");
+    ExpressionPath period = beanType.expressionPath("period");
+    ExpressionPath duration = beanType.expressionPath("duration");
 
     localDate.pathSet(testBean, refBean.getLocalDate());
     assertThat(localDate.pathGet(testBean)).isEqualTo(refBean.getLocalDate());
diff --git a/ebean-core/src/test/java/org/tests/types/TestPeriodType.java b/ebean-test/src/test/java/org/tests/types/TestPeriodType.java
similarity index 66%
rename from ebean-core/src/test/java/org/tests/types/TestPeriodType.java
rename to ebean-test/src/test/java/org/tests/types/TestPeriodType.java
index 7d7dc995a..e398e85bb 100644
--- a/ebean-core/src/test/java/org/tests/types/TestPeriodType.java
+++ b/ebean-test/src/test/java/org/tests/types/TestPeriodType.java
@@ -1,8 +1,8 @@
 package org.tests.types;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.types.SomePeriodBean;
 
 import java.sql.Date;
@@ -10,8 +10,8 @@ import java.time.LocalDate;
 import java.time.MonthDay;
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class TestPeriodType extends BaseTestCase {
 
@@ -20,19 +20,19 @@ public class TestPeriodType extends BaseTestCase {
 
     SomePeriodBean bean = new SomePeriodBean();
     bean.setAnniversary(MonthDay.of(4, 29));
-    Ebean.save(bean);
+    DB.save(bean);
 
-    SomePeriodBean bean1 = Ebean.find(SomePeriodBean.class, bean.getId());
+    SomePeriodBean bean1 = DB.find(SomePeriodBean.class, bean.getId());
     assertEquals(bean.getAnniversary(), bean1.getAnniversary());
 
     // insert fetch null value
     SomePeriodBean bean2 = new SomePeriodBean();
-    Ebean.save(bean2);
+    DB.save(bean2);
 
-    SomePeriodBean bean3 = Ebean.find(SomePeriodBean.class, bean2.getId());
+    SomePeriodBean bean3 = DB.find(SomePeriodBean.class, bean2.getId());
     assertNull(bean3.getAnniversary());
 
-    List<SomePeriodBean> anniversaryList = Ebean.find(SomePeriodBean.class)
+    List<SomePeriodBean> anniversaryList = DB.find(SomePeriodBean.class)
       .where()
       .eq("anniversary", MonthDay.of(4, 29))
       .findList();
@@ -41,7 +41,7 @@ public class TestPeriodType extends BaseTestCase {
 
     // must use year 2000 for range predicates
     // ... using 2001 here so not finding anything
-    anniversaryList = Ebean.find(SomePeriodBean.class)
+    anniversaryList = DB.find(SomePeriodBean.class)
       .where()
       .gt("anniversary", Date.valueOf(LocalDate.of(2001, 4, 29)))
       .findList();
@@ -50,15 +50,15 @@ public class TestPeriodType extends BaseTestCase {
 
     // can use year 2000 for range predicates
     // ... and can use LocalDate to bind
-    anniversaryList = Ebean.find(SomePeriodBean.class)
+    anniversaryList = DB.find(SomePeriodBean.class)
       .where()
       .gt("anniversary", MonthDay.of(4, 22))
       .findList();
 
     assertEquals(1, anniversaryList.size());
 
-    Ebean.delete(bean);
-    Ebean.delete(bean2);
+    DB.delete(bean);
+    DB.delete(bean2);
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/unidirectional/TestUniDirectional.java b/ebean-test/src/test/java/org/tests/unidirectional/TestUniDirectional.java
similarity index 57%
rename from ebean-core/src/test/java/org/tests/unidirectional/TestUniDirectional.java
rename to ebean-test/src/test/java/org/tests/unidirectional/TestUniDirectional.java
index 244678cfd..daa493385 100644
--- a/ebean-core/src/test/java/org/tests/unidirectional/TestUniDirectional.java
+++ b/ebean-test/src/test/java/org/tests/unidirectional/TestUniDirectional.java
@@ -1,14 +1,16 @@
 package org.tests.unidirectional;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UTDetail;
 import org.tests.model.basic.UTMaster;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestUniDirectional extends BaseTestCase {
 
   @Test
@@ -20,32 +22,32 @@ public class TestUniDirectional extends BaseTestCase {
     m.addDetail(new UTDetail("d12", 3, 5.50));
     m.addDetail(new UTDetail("d13", 5, 1.0));
 
-    Ebean.save(m);
+    DB.save(m);
 
-    Assert.assertNotNull(m.getId());
-    Assert.assertNotNull(m.getVersion());
+    assertNotNull(m.getId());
+    assertNotNull(m.getVersion());
 
     List<UTDetail> details = m.getDetails();
     for (UTDetail utDetail : details) {
-      Assert.assertNotNull(utDetail.getId());
-      Assert.assertNotNull(utDetail.getVersion());
+      assertNotNull(utDetail.getId());
+      assertNotNull(utDetail.getVersion());
     }
 
     UTDetail d4 = new UTDetail("d14", 2, 3.0);
     m.addDetail(d4);
 
-    Ebean.save(m);
+    DB.save(m);
 
-    Assert.assertNotNull(d4.getId());
+    assertNotNull(d4.getId());
     Integer d4ver = d4.getVersion();
-    Assert.assertNotNull(d4ver);
+    assertNotNull(d4ver);
 
     d4.setName("d14Upd");
-    Ebean.save(d4);
+    DB.save(d4);
     Integer d4ver2 = d4.getVersion();
-    Assert.assertNotNull(d4ver2);
-    Assert.assertEquals((d4ver + 1), d4ver2.intValue());
+    assertNotNull(d4ver2);
+    assertEquals((d4ver + 1), d4ver2.intValue());
 
-    Ebean.delete(d4);
+    DB.delete(d4);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/unitinternal/HelloMain.java b/ebean-test/src/test/java/org/tests/unitinternal/HelloMain.java
similarity index 81%
rename from ebean-core/src/test/java/org/tests/unitinternal/HelloMain.java
rename to ebean-test/src/test/java/org/tests/unitinternal/HelloMain.java
index 3ca929553..d679d31a6 100644
--- a/ebean-core/src/test/java/org/tests/unitinternal/HelloMain.java
+++ b/ebean-test/src/test/java/org/tests/unitinternal/HelloMain.java
@@ -1,8 +1,8 @@
 package org.tests.unitinternal;
 
-import io.ebean.EbeanServer;
-import io.ebean.EbeanServerFactory;
-import io.ebean.config.ServerConfig;
+import io.ebean.Database;
+import io.ebean.DatabaseFactory;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.datasource.DataSourceConfig;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -16,7 +16,7 @@ public class HelloMain {
 
   public static void main(String[] args) {
     // ### Configuration Objects ###
-    ServerConfig serverConfig = new ServerConfig();
+    DatabaseConfig serverConfig = new DatabaseConfig();
     DataSourceConfig dataSourceConfig = new DataSourceConfig();
 
     // ### Configuration Settings ###
@@ -37,7 +37,7 @@ public class HelloMain {
       serverConfig.addClass(TOne.class);
     }
 
-    EbeanServer eServer = EbeanServerFactory.createWithContextClassLoader(serverConfig, HelloMain.class.getClassLoader());
+    Database eServer = DatabaseFactory.createWithContextClassLoader(serverConfig, HelloMain.class.getClassLoader());
 
     long id = 1;
     TOne data = eServer.find(TOne.class, id);
@@ -49,7 +49,7 @@ public class HelloMain {
       System.out.println(String.format("############\n%s############", data.getName()));
     }
 
-    EbeanServerFactory.shutdown();
+    DatabaseFactory.shutdown();
   }
 
 }
diff --git a/ebean-test/src/test/java/org/tests/unitinternal/TestEqualsOnEnhanced.java b/ebean-test/src/test/java/org/tests/unitinternal/TestEqualsOnEnhanced.java
new file mode 100644
index 000000000..915df69e0
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/unitinternal/TestEqualsOnEnhanced.java
@@ -0,0 +1,35 @@
+package org.tests.unitinternal;
+
+import io.ebean.BaseTestCase;
+import org.junit.jupiter.api.Test;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+
+public class TestEqualsOnEnhanced extends BaseTestCase {
+
+  @Test
+  public void test() {
+    Customer c = new Customer();
+    Order o = new Order();
+
+    c.setId(1);
+    o.setId(1);
+    assertNotEquals(c, o);
+    assertNotEquals(null, c);
+    assertEquals(c, c);
+
+    Customer c2 = new Customer();
+    c2.setId(1);
+    assertEquals(c, c2);
+
+    Customer c3 = new Customer();
+    assertNotEquals(c, c3);
+
+    Customer c4 = new Customer();
+    c4.setId(2);
+    assertNotEquals(c, c4);
+  }
+}
diff --git a/ebean-core/src/test/java/org/tests/unitinternal/TestNamingConvention.java b/ebean-test/src/test/java/org/tests/unitinternal/TestNamingConvention.java
similarity index 95%
rename from ebean-core/src/test/java/org/tests/unitinternal/TestNamingConvention.java
rename to ebean-test/src/test/java/org/tests/unitinternal/TestNamingConvention.java
index 4db75771e..48df8f825 100644
--- a/ebean-core/src/test/java/org/tests/unitinternal/TestNamingConvention.java
+++ b/ebean-test/src/test/java/org/tests/unitinternal/TestNamingConvention.java
@@ -1,12 +1,13 @@
 package org.tests.unitinternal;
 
-import junit.framework.TestCase;
+import org.junit.jupiter.api.Test;
 
-public class TestNamingConvention extends TestCase {
+public class TestNamingConvention {
 
   /**
    * Test dummy method to allow rest to be commented out.
    */
+  @Test
   public void testDummy() {
 
   }
diff --git a/ebean-core/src/test/java/org/tests/unitinternal/TestNullCollectionSet.java b/ebean-test/src/test/java/org/tests/unitinternal/TestNullCollectionSet.java
similarity index 52%
rename from ebean-core/src/test/java/org/tests/unitinternal/TestNullCollectionSet.java
rename to ebean-test/src/test/java/org/tests/unitinternal/TestNullCollectionSet.java
index 7e00c5978..668be5317 100644
--- a/ebean-core/src/test/java/org/tests/unitinternal/TestNullCollectionSet.java
+++ b/ebean-test/src/test/java/org/tests/unitinternal/TestNullCollectionSet.java
@@ -1,37 +1,37 @@
 package org.tests.unitinternal;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.BeanCollection;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.ENullCollection;
 import org.tests.model.basic.ENullCollectionDetail;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestNullCollectionSet extends BaseTestCase {
 
   @Test
   public void test() {
-
     ENullCollection c = new ENullCollection();
 
-    Ebean.save(c);
+    DB.save(c);
 
-    ENullCollection c2 = Ebean.find(ENullCollection.class, c.getId());
+    ENullCollection c2 = DB.find(ENullCollection.class, c.getId());
 
-    Assert.assertNotNull(c2);
+    assertNotNull(c2);
 
     List<ENullCollectionDetail> details = c2.getDetails();
-    Assert.assertNotNull(details);
+    assertNotNull(details);
 
-    Assert.assertTrue("Is BeanCollection", details instanceof BeanCollection<?>);
+    assertTrue(details instanceof BeanCollection<?>);
 
     BeanCollection<?> bc = (BeanCollection<?>) details;
-    Assert.assertTrue(!bc.isPopulated());
-    Assert.assertNotNull(bc.getOwnerBean());
-    Assert.assertNotNull(bc.getPropertyName());
+    assertFalse(bc.isPopulated());
+    assertNotNull(bc.getOwnerBean());
+    assertNotNull(bc.getPropertyName());
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/unitinternal/TestOrderByParse.java b/ebean-test/src/test/java/org/tests/unitinternal/TestOrderByParse.java
similarity index 90%
rename from ebean-core/src/test/java/org/tests/unitinternal/TestOrderByParse.java
rename to ebean-test/src/test/java/org/tests/unitinternal/TestOrderByParse.java
index 11136a786..3f65621b6 100644
--- a/ebean-core/src/test/java/org/tests/unitinternal/TestOrderByParse.java
+++ b/ebean-test/src/test/java/org/tests/unitinternal/TestOrderByParse.java
@@ -2,14 +2,10 @@ package org.tests.unitinternal;
 
 import io.ebean.BaseTestCase;
 import io.ebean.OrderBy;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 /**
  * Test the OrderBy object and especially its parsing.
@@ -46,7 +42,7 @@ public class TestOrderByParse extends BaseTestCase {
     o1 = new OrderBy<>("id desc");
     assertEquals(1, o1.getProperties().size());
     assertEquals("id", o1.getProperties().get(0).getProperty());
-    assertTrue(!o1.getProperties().get(0).isAscending());
+    assertFalse(o1.getProperties().get(0).isAscending());
     assertEquals("id desc", o1.toStringFormat());
 
     o1 = new OrderBy<>(" id  asc ");
@@ -65,7 +61,7 @@ public class TestOrderByParse extends BaseTestCase {
     OrderBy<Object> o1 = new OrderBy<>("id desc nulls high");
     assertEquals(1, o1.getProperties().size());
     assertEquals("id", o1.getProperties().get(0).getProperty());
-    assertTrue(!o1.getProperties().get(0).isAscending());
+    assertFalse(o1.getProperties().get(0).isAscending());
     assertEquals("id desc nulls high", o1.toStringFormat());
     assertFalse(o1.supportsSelect());
   }
@@ -77,7 +73,7 @@ public class TestOrderByParse extends BaseTestCase {
     o1.add("id desc nulls high");
     assertEquals(1, o1.getProperties().size());
     assertEquals("id", o1.getProperties().get(0).getProperty());
-    assertTrue(!o1.getProperties().get(0).isAscending());
+    assertFalse(o1.getProperties().get(0).isAscending());
     assertEquals("id desc nulls high", o1.toStringFormat());
   }
 
@@ -87,7 +83,7 @@ public class TestOrderByParse extends BaseTestCase {
     OrderBy<Object> o1 = new OrderBy<>("id desc nulls high, name");
     assertEquals(2, o1.getProperties().size());
     assertEquals("id", o1.getProperties().get(0).getProperty());
-    assertTrue(!o1.getProperties().get(0).isAscending());
+    assertFalse(o1.getProperties().get(0).isAscending());
     assertEquals("id desc nulls high, name", o1.toStringFormat());
     assertEquals("name", o1.getProperties().get(1).getProperty());
     assertTrue(o1.getProperties().get(1).isAscending());
@@ -116,9 +112,9 @@ public class TestOrderByParse extends BaseTestCase {
     o1 = new OrderBy<>("  id desc , name  desc ");
     assertEquals(2, o1.getProperties().size());
     assertEquals("id", o1.getProperties().get(0).getProperty());
-    assertTrue(!o1.getProperties().get(0).isAscending());
+    assertFalse(o1.getProperties().get(0).isAscending());
     assertEquals("name", o1.getProperties().get(1).getProperty());
-    assertTrue(!o1.getProperties().get(1).isAscending());
+    assertFalse(o1.getProperties().get(1).isAscending());
     assertEquals("id desc, name desc", o1.toStringFormat());
 
     o1 = new OrderBy<>("  id ascending, name  asc");
@@ -149,9 +145,9 @@ public class TestOrderByParse extends BaseTestCase {
     o1.desc("name");
     assertEquals(2, o1.getProperties().size());
     assertEquals("id", o1.getProperties().get(0).getProperty());
-    assertTrue(!o1.getProperties().get(0).isAscending());
+    assertFalse(o1.getProperties().get(0).isAscending());
     assertEquals("name", o1.getProperties().get(1).getProperty());
-    assertTrue(!o1.getProperties().get(1).isAscending());
+    assertFalse(o1.getProperties().get(1).isAscending());
     assertEquals("id desc, name desc", o1.toStringFormat());
 
     o1.reverse();
@@ -188,7 +184,7 @@ public class TestOrderByParse extends BaseTestCase {
     o1.desc("id", "latin_1");
     assertEquals(1, o1.getProperties().size());
     assertEquals("id", o1.getProperties().get(0).getProperty());
-    assertTrue(!o1.getProperties().get(0).isAscending());
+    assertFalse(o1.getProperties().get(0).isAscending());
     assertEquals("id collate latin_1 desc", o1.toStringFormat());
     assertTrue(o1.supportsSelect());
 
@@ -198,7 +194,7 @@ public class TestOrderByParse extends BaseTestCase {
     assertEquals(2, o1.getProperties().size());
     assertEquals("id", o1.getProperties().get(0).getProperty());
     assertEquals("date", o1.getProperties().get(1).getProperty());
-    assertTrue(!o1.getProperties().get(0).isAscending());
+    assertFalse(o1.getProperties().get(0).isAscending());
     assertTrue(o1.getProperties().get(1).isAscending());
     assertEquals("id collate latin_1 desc, date", o1.toStringFormat());
     assertTrue(o1.supportsSelect());
@@ -209,7 +205,7 @@ public class TestOrderByParse extends BaseTestCase {
     assertEquals(2, o1.getProperties().size());
     assertEquals("id", o1.getProperties().get(0).getProperty());
     assertEquals("name", o1.getProperties().get(1).getProperty());
-    assertTrue(!o1.getProperties().get(0).isAscending());
+    assertFalse(o1.getProperties().get(0).isAscending());
     assertTrue(o1.getProperties().get(1).isAscending());
     assertEquals("id collate latin_1 desc, name collate latin_2", o1.toStringFormat());
     assertTrue(o1.supportsSelect());
@@ -219,7 +215,7 @@ public class TestOrderByParse extends BaseTestCase {
     o1.desc("id", "COLLATION_KEY(${}, 'latin_1')");
     assertEquals(1, o1.getProperties().size());
     assertEquals("id", o1.getProperties().get(0).getProperty());
-    assertTrue(!o1.getProperties().get(0).isAscending());
+    assertFalse(o1.getProperties().get(0).isAscending());
     assertEquals("COLLATION_KEY(id, 'latin_1') desc", o1.toStringFormat());
     assertTrue(o1.supportsSelect());
   }
@@ -235,7 +231,6 @@ public class TestOrderByParse extends BaseTestCase {
     assertEquals(o1, o2);
     assertEquals(o1, o3);
 
-
     OrderBy<Object> o4 = new OrderBy<>("id desc");
     OrderBy<Object> o5 = new OrderBy<>("oid desc nulls high");
     OrderBy<Object> o6 = new OrderBy<>("id desc nulls low");
@@ -247,7 +242,6 @@ public class TestOrderByParse extends BaseTestCase {
 
   @Test
   public void equals_with_collation() {
-
     OrderBy<Object> o1 = new OrderBy<>();
     o1.asc("name", "latin_1");
 
diff --git a/ebean-core/src/test/java/org/tests/unitinternal/TestTxTypeOnTransactional.java b/ebean-test/src/test/java/org/tests/unitinternal/TestTxTypeOnTransactional.java
similarity index 85%
rename from ebean-core/src/test/java/org/tests/unitinternal/TestTxTypeOnTransactional.java
rename to ebean-test/src/test/java/org/tests/unitinternal/TestTxTypeOnTransactional.java
index 7be4ccc01..fcfcb5aef 100644
--- a/ebean-core/src/test/java/org/tests/unitinternal/TestTxTypeOnTransactional.java
+++ b/ebean-test/src/test/java/org/tests/unitinternal/TestTxTypeOnTransactional.java
@@ -1,18 +1,20 @@
 package org.tests.unitinternal;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.Transaction;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.tests.model.basic.EBasicVer;
 import org.tests.model.basic.xtra.DummyDao;
 import org.tests.model.basic.xtra.OptimisticLockExceptionThrowingDao;
-import org.junit.Assert;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import javax.persistence.OptimisticLockException;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
 public class TestTxTypeOnTransactional extends BaseTestCase {
 
   Logger logger = LoggerFactory.getLogger(TestTxTypeOnTransactional.class);
@@ -40,18 +42,17 @@ public class TestTxTypeOnTransactional extends BaseTestCase {
     logger.info("-- testOptimisticException");
     EBasicVer v = new EBasicVer("occ");
     v.setDescription("blah");
-    Ebean.save(v);
+    DB.save(v);
 
     logger.info("-- OptimisticLockExceptionThrowingDao");
     OptimisticLockExceptionThrowingDao dao = new OptimisticLockExceptionThrowingDao();
     try {
       dao.doSomething(v);
       // never get here
-      Assert.assertTrue(false);
+      fail();
     } catch (OptimisticLockException e) {
       Transaction inMethodTransaction = dao.getInMethodTransaction();
-      boolean active = inMethodTransaction.isActive();
-      Assert.assertFalse(active);
+      assertFalse(inMethodTransaction.isActive());
     }
   }
 
diff --git a/ebean-core/src/test/java/org/tests/unitinternal/TestVanillaCollectionSet.java b/ebean-test/src/test/java/org/tests/unitinternal/TestVanillaCollectionSet.java
similarity index 53%
rename from ebean-core/src/test/java/org/tests/unitinternal/TestVanillaCollectionSet.java
rename to ebean-test/src/test/java/org/tests/unitinternal/TestVanillaCollectionSet.java
index e445ef954..c580d23cf 100644
--- a/ebean-core/src/test/java/org/tests/unitinternal/TestVanillaCollectionSet.java
+++ b/ebean-test/src/test/java/org/tests/unitinternal/TestVanillaCollectionSet.java
@@ -1,15 +1,16 @@
 package org.tests.unitinternal;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.bean.BeanCollection;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EVanillaCollection;
 import org.tests.model.basic.EVanillaCollectionDetail;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 public class TestVanillaCollectionSet extends BaseTestCase {
 
   @Test
@@ -17,21 +18,21 @@ public class TestVanillaCollectionSet extends BaseTestCase {
 
     EVanillaCollection c = new EVanillaCollection();
 
-    Ebean.save(c);
+    DB.save(c);
 
-    EVanillaCollection c2 = Ebean.find(EVanillaCollection.class, c.getId());
+    EVanillaCollection c2 = DB.find(EVanillaCollection.class, c.getId());
 
-    Assert.assertNotNull(c2);
+    assertNotNull(c2);
 
     List<EVanillaCollectionDetail> details = c2.getDetails();
-    Assert.assertNotNull(details);
+    assertNotNull(details);
 
-    Assert.assertTrue("Is BeanCollection", details instanceof BeanCollection<?>);
+    assertTrue(details instanceof BeanCollection<?>);
 
     BeanCollection<?> bc = (BeanCollection<?>) details;
-    Assert.assertTrue(!bc.isPopulated());
-    Assert.assertNotNull(bc.getOwnerBean());
-    Assert.assertNotNull(bc.getPropertyName());
+    assertFalse(bc.isPopulated());
+    assertNotNull(bc.getOwnerBean());
+    assertNotNull(bc.getPropertyName());
   }
 
 }
diff --git a/ebean-core/src/test/java/org/tests/update/EPersonOnline.java b/ebean-test/src/test/java/org/tests/update/EPersonOnline.java
similarity index 100%
rename from ebean-core/src/test/java/org/tests/update/EPersonOnline.java
rename to ebean-test/src/test/java/org/tests/update/EPersonOnline.java
diff --git a/ebean-core/src/test/java/org/tests/update/TestEmbeddedRefreshUpdate.java b/ebean-test/src/test/java/org/tests/update/TestEmbeddedRefreshUpdate.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/update/TestEmbeddedRefreshUpdate.java
rename to ebean-test/src/test/java/org/tests/update/TestEmbeddedRefreshUpdate.java
index 97528f820..3bc09dae3 100644
--- a/ebean-core/src/test/java/org/tests/update/TestEmbeddedRefreshUpdate.java
+++ b/ebean-test/src/test/java/org/tests/update/TestEmbeddedRefreshUpdate.java
@@ -1,11 +1,11 @@
 package org.tests.update;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.embedded.EEmbDatePeriod;
 import org.tests.model.embedded.EEmbInner;
 import org.tests.model.embedded.EEmbOuter;
-import org.junit.Test;
 
 import java.util.Date;
 
@@ -24,20 +24,20 @@ public class TestEmbeddedRefreshUpdate extends BaseTestCase {
 
     outer.setDatePeriod(embeddedBean);
 
-    Ebean.save(outer);
+    DB.save(outer);
 
-    EEmbOuter loaded = Ebean.find(EEmbOuter.class).where().idEq(outer.getId()).findOne();
+    EEmbOuter loaded = DB.find(EEmbOuter.class).where().idEq(outer.getId()).findOne();
 
     // if commented Ebean saves correctly
-    Ebean.refresh(loaded);
+    DB.refresh(loaded);
 
     loaded.getDatePeriod().setDate2(new Date());
 
     // BUG 343
-    Ebean.save(loaded);
+    DB.save(loaded);
 
     // See BUG 344
-    Ebean.find(EEmbInner.class).fetch("outer").orderBy("outer.datePeriod.date1").findList();
+    DB.find(EEmbInner.class).fetch("outer").orderBy("outer.datePeriod.date1").findList();
 
   }
 
@@ -50,14 +50,14 @@ public class TestEmbeddedRefreshUpdate extends BaseTestCase {
     embeddedBean.setDate1(new Date());
     outer.setDatePeriod(embeddedBean);
 
-    Ebean.save(outer);
+    DB.save(outer);
     assertThat(outer.getUpdateCount()).isEqualTo(1);
 
     Date d = new Date();
     d.setTime(1L);
 
     outer.getDatePeriod().setDate1(d);
-    Ebean.save(outer);
+    DB.save(outer);
     assertThat(outer.getUpdateCount()).isEqualTo(2);
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/update/TestJsonStatelessUpdate.java b/ebean-test/src/test/java/org/tests/update/TestJsonStatelessUpdate.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/update/TestJsonStatelessUpdate.java
rename to ebean-test/src/test/java/org/tests/update/TestJsonStatelessUpdate.java
index f05b74f6d..009283e11 100644
--- a/ebean-core/src/test/java/org/tests/update/TestJsonStatelessUpdate.java
+++ b/ebean-test/src/test/java/org/tests/update/TestJsonStatelessUpdate.java
@@ -1,16 +1,17 @@
 package org.tests.update;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.text.json.JsonContext;
 import io.ebean.text.json.JsonWriteOptions;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.UUOne;
 import org.tests.model.basic.UUTwo;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.io.IOException;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestJsonStatelessUpdate extends BaseTestCase {
 
   @Test
@@ -19,17 +20,17 @@ public class TestJsonStatelessUpdate extends BaseTestCase {
     UUOne one = new UUOne();
     one.setName("oneName");
 
-    Ebean.save(one);
+    DB.save(one);
 
     UUTwo two = new UUTwo();
     two.setMaster(one);
     two.setName("twoName");
 
-    Ebean.save(two);
+    DB.save(two);
 
-    UUTwo twoX = Ebean.find(UUTwo.class, two.getId());
+    UUTwo twoX = DB.find(UUTwo.class, two.getId());
 
-    JsonContext jsonContext = Ebean.json();
+    JsonContext jsonContext = DB.json();
 
     JsonWriteOptions writeOptions = JsonWriteOptions.parsePath("(id,name,master(*))");
     String jsonString = jsonContext.toJson(twoX, writeOptions);
@@ -40,22 +41,22 @@ public class TestJsonStatelessUpdate extends BaseTestCase {
 
     UUTwo two2 = jsonContext.toBean(UUTwo.class, jsonString);
 
-    Assert.assertEquals(twoX.getId(), two2.getId());
-    Assert.assertEquals("twoNameModified", two2.getName());
-    Assert.assertEquals("oneNameModified", two2.getMaster().getName());
+    assertEquals(twoX.getId(), two2.getId());
+    assertEquals("twoNameModified", two2.getName());
+    assertEquals("oneNameModified", two2.getMaster().getName());
 
     // The update below cascades to also save "master" and that fails
     // as it thinks it should INSERT master rather than UPDATE master
 
-    Ebean.update(two2);
+    DB.update(two2);
     awaitL2Cache();
 
 
     // confirm the properties where updated as expected
-    UUTwo twoConfirm = Ebean.find(UUTwo.class, two.getId());
+    UUTwo twoConfirm = DB.find(UUTwo.class, two.getId());
 
-    Assert.assertEquals("twoNameModified", twoConfirm.getName());
-    Assert.assertEquals("oneNameModified", twoConfirm.getMaster().getName());
+    assertEquals("twoNameModified", twoConfirm.getName());
+    assertEquals("oneNameModified", twoConfirm.getMaster().getName());
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/update/TestMarkAsDirty.java b/ebean-test/src/test/java/org/tests/update/TestMarkAsDirty.java
similarity index 58%
rename from ebean-core/src/test/java/org/tests/update/TestMarkAsDirty.java
rename to ebean-test/src/test/java/org/tests/update/TestMarkAsDirty.java
index f3da6422f..49d6f7222 100644
--- a/ebean-core/src/test/java/org/tests/update/TestMarkAsDirty.java
+++ b/ebean-test/src/test/java/org/tests/update/TestMarkAsDirty.java
@@ -1,33 +1,35 @@
 package org.tests.update;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
-import org.junit.Assert;
-import org.junit.Test;
 
 import java.sql.Timestamp;
 
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 public class TestMarkAsDirty extends BaseTestCase {
 
   @Test
   public void test() throws InterruptedException {
 
     EBasicVer bean = new EBasicVer("markAsDirty");
-    Ebean.save(bean);
+    DB.save(bean);
 
     Timestamp lastUpdate = bean.getLastUpdate();
-    Assert.assertNotNull(lastUpdate);
+    assertNotNull(lastUpdate);
 
     Thread.sleep(100);
 
     // ensure the update occurs and version property is updated/incremented
-    Ebean.markAsDirty(bean);
-    Ebean.save(bean);
+    DB.markAsDirty(bean);
+    DB.save(bean);
 
     Timestamp lastUpdate2 = bean.getLastUpdate();
-    Assert.assertNotNull(lastUpdate2);
-    Assert.assertNotEquals(lastUpdate, lastUpdate2);
+    assertNotNull(lastUpdate2);
+    assertNotEquals(lastUpdate, lastUpdate2);
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/update/TestPostgresTruncate.java b/ebean-test/src/test/java/org/tests/update/TestPostgresTruncate.java
similarity index 54%
rename from ebean-core/src/test/java/org/tests/update/TestPostgresTruncate.java
rename to ebean-test/src/test/java/org/tests/update/TestPostgresTruncate.java
index e8559bb0d..f8d32bcca 100644
--- a/ebean-core/src/test/java/org/tests/update/TestPostgresTruncate.java
+++ b/ebean-test/src/test/java/org/tests/update/TestPostgresTruncate.java
@@ -1,16 +1,13 @@
 package org.tests.update;
 
 import io.ebean.BaseTestCase;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class TestPostgresTruncate extends BaseTestCase {
 
   @Test
   public void test() {
-
-    Assert.assertTrue(true);
-    // EbeanServer server = Ebean.getServer(null);
+    // Database server = DB.getDefault();
     //
     // EBasic e = new EBasic();
     // e.setName("something");
@@ -21,12 +18,12 @@ public class TestPostgresTruncate extends BaseTestCase {
     //
     // server.beginTransaction();
     // Integer oriC =
-    // Ebean.createSqlQuery("select count(*) as c from e_basic").findOne().getInteger("c");
-    // int rows = Ebean.createSqlUpdate("truncate e_basic cascade").execute();
+    // DB.sqlQuery("select count(*) as c from e_basic").findOne().getInteger("c");
+    // int rows = DB.sqlUpdate("truncate e_basic cascade").execute();
     // Integer currentC =
-    // Ebean.createSqlQuery("select count(*) as c from e_basic").findOne().getInteger("c");
+    // DB.sqlQuery("select count(*) as c from e_basic").findOne().getInteger("c");
     // server.commitTransaction();
-    // //Ebean.getServerCacheManager().clearAll();
+    // //DB.cacheManager().clearAll();
     // System.out.println("table : ori="+oriC+", delC="+rows+", currentC="+currentC);
 
   }
diff --git a/ebean-core/src/test/java/org/tests/update/TestSqlUpdateBatch.java b/ebean-test/src/test/java/org/tests/update/TestSqlUpdateBatch.java
similarity index 96%
rename from ebean-core/src/test/java/org/tests/update/TestSqlUpdateBatch.java
rename to ebean-test/src/test/java/org/tests/update/TestSqlUpdateBatch.java
index 1cc735fa0..cd06f3711 100644
--- a/ebean-core/src/test/java/org/tests/update/TestSqlUpdateBatch.java
+++ b/ebean-test/src/test/java/org/tests/update/TestSqlUpdateBatch.java
@@ -4,10 +4,10 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.SqlUpdate;
 import io.ebean.Transaction;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * Testclass that ensures the correct behaviour of SqlUpdate in combination with batching.
diff --git a/ebean-core/src/test/java/org/tests/update/TestSqlUpdateBindMultipleLists.java b/ebean-test/src/test/java/org/tests/update/TestSqlUpdateBindMultipleLists.java
similarity index 98%
rename from ebean-core/src/test/java/org/tests/update/TestSqlUpdateBindMultipleLists.java
rename to ebean-test/src/test/java/org/tests/update/TestSqlUpdateBindMultipleLists.java
index b81597eab..1c05bed7f 100644
--- a/ebean-core/src/test/java/org/tests/update/TestSqlUpdateBindMultipleLists.java
+++ b/ebean-test/src/test/java/org/tests/update/TestSqlUpdateBindMultipleLists.java
@@ -4,21 +4,21 @@ import io.ebean.BaseTestCase;
 import io.ebean.DB;
 import io.ebean.SqlUpdate;
 import io.ebean.Transaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestSqlUpdateBindMultipleLists extends BaseTestCase {
 
   @Test
   public void test() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
     SqlUpdate sqlUpdate = DB.sqlUpdate("delete from o_customer where id in (:ids)");
 
@@ -31,7 +31,7 @@ public class TestSqlUpdateBindMultipleLists extends BaseTestCase {
     sqlUpdate.execute();
     assertEquals("delete from o_customer where id in (?,?)", sqlUpdate.getGeneratedSql());
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
   }
 
diff --git a/ebean-core/src/test/java/org/tests/update/TestSqlUpdateExceptions.java b/ebean-test/src/test/java/org/tests/update/TestSqlUpdateExceptions.java
similarity index 51%
rename from ebean-core/src/test/java/org/tests/update/TestSqlUpdateExceptions.java
rename to ebean-test/src/test/java/org/tests/update/TestSqlUpdateExceptions.java
index 8253f7c87..0aad43977 100644
--- a/ebean-core/src/test/java/org/tests/update/TestSqlUpdateExceptions.java
+++ b/ebean-test/src/test/java/org/tests/update/TestSqlUpdateExceptions.java
@@ -1,15 +1,12 @@
 package org.tests.update;
 
-import io.ebean.BaseTestCase;
-import io.ebean.DB;
-import io.ebean.DuplicateKeyException;
-import io.ebean.SqlUpdate;
-import io.ebean.Transaction;
-import org.junit.Test;
+import io.ebean.*;
+import org.junit.jupiter.api.Test;
 
 import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class TestSqlUpdateExceptions extends BaseTestCase {
 
@@ -32,9 +29,8 @@ public class TestSqlUpdateExceptions extends BaseTestCase {
     assertThat(foundId).isEqualTo(id);
   }
 
-  @Test(expected = DuplicateKeyException.class)
+  @Test
   public void duplicateKey() {
-
     UUID id = UUID.randomUUID();
 
     SqlUpdate sqlUpdate = DB.sqlUpdate(sql);
@@ -46,12 +42,11 @@ public class TestSqlUpdateExceptions extends BaseTestCase {
     sqlUpdate.setParameter(1, id);
     sqlUpdate.setParameter(2, "fail");
     sqlUpdate.setParameter(3, 1);
-    sqlUpdate.execute();
+    assertThrows(DuplicateKeyException.class, sqlUpdate::execute);
   }
 
-  @Test(expected = DuplicateKeyException.class)
+  @Test
   public void duplicateKey_executeNow() {
-
     UUID id = UUID.randomUUID();
 
     SqlUpdate sqlUpdate = DB.sqlUpdate(sql);
@@ -63,51 +58,50 @@ public class TestSqlUpdateExceptions extends BaseTestCase {
     sqlUpdate.setParameter(1, id);
     sqlUpdate.setParameter(2, "fail");
     sqlUpdate.setParameter(3, 1);
-    sqlUpdate.executeNow();
+    assertThrows(DuplicateKeyException.class, sqlUpdate::executeNow);
   }
 
-  @Test(expected = DuplicateKeyException.class)
+  @Test
   public void duplicateKey_inBatch() {
-
     UUID id = UUID.randomUUID();
+    assertThrows(DuplicateKeyException.class, () -> {
+      try (Transaction transaction = DB.beginTransaction()) {
 
-    try (Transaction transaction = DB.beginTransaction()) {
+        SqlUpdate sqlUpdate = DB.sqlUpdate(sql);
+        sqlUpdate.setParameter(1, id);
+        sqlUpdate.setParameter(2, "hi in batch");
+        sqlUpdate.setParameter(3, 1);
+        sqlUpdate.addBatch();
 
-      SqlUpdate sqlUpdate = DB.sqlUpdate(sql);
-      sqlUpdate.setParameter(1, id);
-      sqlUpdate.setParameter(2, "hi in batch");
-      sqlUpdate.setParameter(3, 1);
-      sqlUpdate.addBatch();
+        sqlUpdate.setParameter(1, id);
+        sqlUpdate.setParameter(2, "fail in batch");
+        sqlUpdate.setParameter(3, 1);
+        sqlUpdate.addBatch();
 
-      sqlUpdate.setParameter(1, id);
-      sqlUpdate.setParameter(2, "fail in batch");
-      sqlUpdate.setParameter(3, 1);
-      sqlUpdate.addBatch();
-
-      transaction.commit();
-    }
+        transaction.commit();
+      }
+    });
   }
 
-  @Test(expected = DuplicateKeyException.class)
+  @Test
   public void duplicateKey_executeBatch() {
-
     UUID id = UUID.randomUUID();
+    assertThrows(DuplicateKeyException.class, () -> {
+      try (Transaction transaction = DB.beginTransaction()) {
+        SqlUpdate sqlUpdate = DB.sqlUpdate(sql);
+        sqlUpdate.setParameter(1, id);
+        sqlUpdate.setParameter(2, "hi in batch");
+        sqlUpdate.setParameter(3, 1);
+        sqlUpdate.addBatch();
 
-    try (Transaction transaction = DB.beginTransaction()) {
+        sqlUpdate.setParameter(1, id);
+        sqlUpdate.setParameter(2, "fail in batch");
+        sqlUpdate.setParameter(3, 1);
+        sqlUpdate.addBatch();
 
-      SqlUpdate sqlUpdate = DB.sqlUpdate(sql);
-      sqlUpdate.setParameter(1, id);
-      sqlUpdate.setParameter(2, "hi in batch");
-      sqlUpdate.setParameter(3, 1);
-      sqlUpdate.addBatch();
-
-      sqlUpdate.setParameter(1, id);
-      sqlUpdate.setParameter(2, "fail in batch");
-      sqlUpdate.setParameter(3, 1);
-      sqlUpdate.addBatch();
-
-      sqlUpdate.executeBatch();
-      transaction.commit();
-    }
+        sqlUpdate.executeBatch();
+        transaction.commit();
+      }
+    });
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/update/TestSqlUpdateInTxn.java b/ebean-test/src/test/java/org/tests/update/TestSqlUpdateInTxn.java
similarity index 63%
rename from ebean-core/src/test/java/org/tests/update/TestSqlUpdateInTxn.java
rename to ebean-test/src/test/java/org/tests/update/TestSqlUpdateInTxn.java
index c539beda8..13d72c689 100644
--- a/ebean-core/src/test/java/org/tests/update/TestSqlUpdateInTxn.java
+++ b/ebean-test/src/test/java/org/tests/update/TestSqlUpdateInTxn.java
@@ -1,18 +1,18 @@
 package org.tests.update;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.SqlUpdate;
 import io.ebean.Transaction;
 import io.ebean.meta.MetaTimedMetric;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Assert;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.idkeys.db.AuditLog;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestSqlUpdateInTxn extends BaseTestCase {
 
@@ -21,7 +21,7 @@ public class TestSqlUpdateInTxn extends BaseTestCase {
 
     String sql = "  this\nis\ntrimmed ";
 
-    SqlUpdate sqlUpdate = Ebean.createSqlUpdate(sql);
+    SqlUpdate sqlUpdate = DB.sqlUpdate(sql);
     assertThat(sqlUpdate.getSql()).isEqualTo(sql.trim());
   }
 
@@ -33,7 +33,7 @@ public class TestSqlUpdateInTxn extends BaseTestCase {
       // and table effected (so no automatic L2 cache invalidation)
       String sql = "CHECKPOINT SYNC";
 
-      SqlUpdate sqlUpdate = Ebean.createSqlUpdate(sql);
+      SqlUpdate sqlUpdate = DB.sqlUpdate(sql);
       sqlUpdate.execute();
 
       assertThat(sqlUpdate.getSql()).isEqualTo(sql.trim());
@@ -43,12 +43,12 @@ public class TestSqlUpdateInTxn extends BaseTestCase {
   @Test
   public void testExecute_inTransaction_withBatch() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    try (Transaction transaction = Ebean.beginTransaction()) {
+    try (Transaction transaction = DB.beginTransaction()) {
       transaction.setBatchMode(true);
 
-      SqlUpdate sqlUpdate = Ebean.createSqlUpdate("update audit_log set description = description where id = ?")
+      SqlUpdate sqlUpdate = DB.sqlUpdate("update audit_log set description = description where id = ?")
         .setParameter(1, 999999);
 
       int row = sqlUpdate.execute();
@@ -61,7 +61,7 @@ public class TestSqlUpdateInTxn extends BaseTestCase {
       transaction.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(3);
     assertSql(sql.get(0)).contains("update audit_log set description = description where id = ?");
     assertSqlBind(sql, 1, 2);
@@ -70,12 +70,12 @@ public class TestSqlUpdateInTxn extends BaseTestCase {
   @Test
   public void testExecute_inTransaction_withoutBatch() {
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
-    try (Transaction transaction = Ebean.beginTransaction()) {
+    try (Transaction transaction = DB.beginTransaction()) {
       transaction.setBatchMode(false);
 
-      SqlUpdate sqlUpdate = Ebean.createSqlUpdate("update audit_log set description = description where id = ?")
+      SqlUpdate sqlUpdate = DB.sqlUpdate("update audit_log set description = description where id = ?")
         .setParameter(1, 999999);
 
       int row0 = sqlUpdate.execute();
@@ -88,7 +88,7 @@ public class TestSqlUpdateInTxn extends BaseTestCase {
       transaction.commit();
     }
 
-    List<String> sql = LoggedSqlCollector.stop();
+    List<String> sql = LoggedSql.stop();
     assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("update audit_log set description = description where id = ?; -- bind(999999)");
     assertSql(sql.get(1)).contains("update audit_log set description = description where id = ?; -- bind(999998)");
@@ -97,10 +97,10 @@ public class TestSqlUpdateInTxn extends BaseTestCase {
   @Test
   public void testExecuteNow_inTransaction_withBatch() {
 
-    try (Transaction transaction = Ebean.beginTransaction()) {
+    try (Transaction transaction = DB.beginTransaction()) {
       transaction.setBatchMode(true);
 
-      int row = Ebean.createSqlUpdate("update audit_log set description = description where id = ?")
+      int row = DB.sqlUpdate("update audit_log set description = description where id = ?")
         .setParameter(1, 999999)
         .executeNow();
 
@@ -118,7 +118,7 @@ public class TestSqlUpdateInTxn extends BaseTestCase {
 
     resetAllMetrics();
 
-    SqlUpdate sqlUpdate = Ebean.createSqlUpdate(sql).setLabel("auditLargeUpdate");
+    SqlUpdate sqlUpdate = DB.sqlUpdate(sql).setLabel("auditLargeUpdate");
     sqlUpdate.execute();
 
     assertThat(sqlUpdate.getSql()).isEqualTo(sql.trim());
@@ -135,67 +135,67 @@ public class TestSqlUpdateInTxn extends BaseTestCase {
 
     AuditLog otherLog = new AuditLog();
     otherLog.setDescription("foo");
-    Ebean.save(otherLog);
+    DB.save(otherLog);
 
     AuditLog log = new AuditLog();
     log.setDescription("foo");
 
-    Ebean.save(log);
+    DB.save(log);
 
-    AuditLog log2 = Ebean.find(AuditLog.class, log.getId());
-    Assert.assertEquals("foo", log2.getDescription());
+    AuditLog log2 = DB.find(AuditLog.class, log.getId());
+    assertEquals("foo", log2.getDescription());
 
     final Long id = log2.getId();
     final String updateDml = "update audit_log set description = :desc where id = :id";
     final String updateModDml = "update audit_log set modified_description = :desc";
 
-    SqlUpdate sqlUpdate = Ebean.createSqlUpdate(updateDml);
+    SqlUpdate sqlUpdate = DB.sqlUpdate(updateDml);
     sqlUpdate.setParameter("desc", "foo2");
     sqlUpdate.setParameter("id", id);
     sqlUpdate.execute();
 
-    SqlUpdate updateMod = Ebean.createSqlUpdate(updateModDml);
+    SqlUpdate updateMod = DB.sqlUpdate(updateModDml);
     updateMod.setParameter("desc", "mod0");
     updateMod.execute();
 
-    AuditLog log3 = Ebean.find(AuditLog.class, log.getId());
-    Assert.assertEquals("foo2", log3.getDescription());
-    Assert.assertEquals("mod0", log3.getModifiedDescription());
+    AuditLog log3 = DB.find(AuditLog.class, log.getId());
+    assertEquals("foo2", log3.getDescription());
+    assertEquals("mod0", log3.getModifiedDescription());
 
-    Ebean.execute(() -> {
-      SqlUpdate update = Ebean.createSqlUpdate(updateDml);
+    DB.execute(() -> {
+      SqlUpdate update = DB.sqlUpdate(updateDml);
       update.setParameter("desc", "foo3");
       update.setParameter("id", id);
       update.execute();
 
-      SqlUpdate updateMod1 = Ebean.createSqlUpdate(updateModDml);
+      SqlUpdate updateMod1 = DB.sqlUpdate(updateModDml);
       updateMod1.setParameter("desc", "mod1");
       updateMod1.execute();
     });
 
-    AuditLog log4 = Ebean.find(AuditLog.class, log.getId());
-    Assert.assertEquals("foo3", log4.getDescription());
-    Assert.assertEquals("mod1", log4.getModifiedDescription());
+    AuditLog log4 = DB.find(AuditLog.class, log.getId());
+    assertEquals("foo3", log4.getDescription());
+    assertEquals("mod1", log4.getModifiedDescription());
 
 
-    Ebean.beginTransaction();
+    DB.beginTransaction();
     try {
-      SqlUpdate update = Ebean.createSqlUpdate(updateDml);
+      SqlUpdate update = DB.sqlUpdate(updateDml);
       update.setParameter("desc", "foo4");
       update.setParameter("id", id);
       update.execute();
 
-      updateMod = Ebean.createSqlUpdate(updateModDml);
+      updateMod = DB.sqlUpdate(updateModDml);
       updateMod.setParameter("desc", "mod2");
       updateMod.execute();
 
-      Ebean.commitTransaction();
+      DB.commitTransaction();
     } finally {
-      Ebean.endTransaction();
+      DB.endTransaction();
     }
-    AuditLog log5 = Ebean.find(AuditLog.class, log.getId());
-    Assert.assertEquals("foo4", log5.getDescription());
-    Assert.assertEquals("mod2", log5.getModifiedDescription());
+    AuditLog log5 = DB.find(AuditLog.class, log.getId());
+    assertEquals("foo4", log5.getDescription());
+    assertEquals("mod2", log5.getModifiedDescription());
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/update/TestSqlUpdateUpsert.java b/ebean-test/src/test/java/org/tests/update/TestSqlUpdateUpsert.java
similarity index 86%
rename from ebean-core/src/test/java/org/tests/update/TestSqlUpdateUpsert.java
rename to ebean-test/src/test/java/org/tests/update/TestSqlUpdateUpsert.java
index 36b7c195b..9cd59bf23 100644
--- a/ebean-core/src/test/java/org/tests/update/TestSqlUpdateUpsert.java
+++ b/ebean-test/src/test/java/org/tests/update/TestSqlUpdateUpsert.java
@@ -2,11 +2,10 @@ package org.tests.update;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.SqlUpdate;
 import io.ebean.annotation.ForPlatform;
 import io.ebean.annotation.Platform;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -26,7 +25,7 @@ public class TestSqlUpdateUpsert extends BaseTestCase {
       .setParameter(true)
       .executeGetKey();
 
-    EPersonOnline found = Ebean.find(EPersonOnline.class, key);
+    EPersonOnline found = DB.find(EPersonOnline.class, key);
     assertThat(found).isNotNull();
     assertThat(found.getEmail()).isEqualTo(email);
     assertThat(found.isOnlineStatus()).isTrue();
@@ -34,7 +33,7 @@ public class TestSqlUpdateUpsert extends BaseTestCase {
     Thread.sleep(50); // have to wait some millis here
     String sqlNamed = "merge into e_person_online (email, online_status, when_updated) key(email) values (:email, :online, now())";
 
-    SqlUpdate sqlUpdate2 = Ebean.createSqlUpdate(sqlNamed)
+    SqlUpdate sqlUpdate2 = DB.sqlUpdate(sqlNamed)
       .setGetGeneratedKeys(true)
       .setParameter("email", email)
       .setParameter("online", false);
@@ -43,7 +42,7 @@ public class TestSqlUpdateUpsert extends BaseTestCase {
     assertThat(key2).isNull();
 
 
-    EPersonOnline found2 = Ebean.find(EPersonOnline.class).where().eq("email", email).findOne();
+    EPersonOnline found2 = DB.find(EPersonOnline.class).where().eq("email", email).findOne();
     assertThat(found2).isNotNull();
     assertThat(found2.getId()).isEqualTo(key);
     assertThat(found2.getEmail()).isEqualTo(email);
@@ -66,7 +65,7 @@ public class TestSqlUpdateUpsert extends BaseTestCase {
       .setParameter(3, true)
       .executeGetKey();
 
-    EPersonOnline found = Ebean.find(EPersonOnline.class, key);
+    EPersonOnline found = DB.find(EPersonOnline.class, key);
     assertThat(found).isNotNull();
     assertThat(found.getEmail()).isEqualTo("foo@one.com");
     assertThat(found.isOnlineStatus()).isTrue();
@@ -80,7 +79,7 @@ public class TestSqlUpdateUpsert extends BaseTestCase {
 
     Object key2 = sqlUpdate2.executeGetKey();
 
-    EPersonOnline found2 = Ebean.find(EPersonOnline.class, key2);
+    EPersonOnline found2 = DB.find(EPersonOnline.class, key2);
     assertThat(found2).isNotNull();
     assertThat(found2.getId()).isEqualTo(key);
     assertThat(found2.getEmail()).isEqualTo("foo@one.com");
@@ -96,7 +95,7 @@ public class TestSqlUpdateUpsert extends BaseTestCase {
     String email = "bar@one.com";
 
     String sql = "insert into e_person_online (email, online_status, when_updated) values (?, ?, current_time) on duplicate key update when_updated=current_time, online_status = ?";
-    SqlUpdate sqlUpdate = Ebean.createSqlUpdate(sql)
+    SqlUpdate sqlUpdate = DB.sqlUpdate(sql)
       .setGetGeneratedKeys(true)
       .setParameter(1, email)
       .setParameter(2, true)
@@ -105,14 +104,14 @@ public class TestSqlUpdateUpsert extends BaseTestCase {
     Object key = sqlUpdate.executeGetKey();
     assertThat(key).isNotNull();
 
-    EPersonOnline found = Ebean.find(EPersonOnline.class, key);
+    EPersonOnline found = DB.find(EPersonOnline.class, key);
     assertThat(found).isNotNull();
     assertThat(found.getEmail()).isEqualTo("bar@one.com");
     assertThat(found.isOnlineStatus()).isTrue();
 
 
     String sqlNamed = "insert into e_person_online (email, online_status, when_updated) values (:email, :online, current_time) on duplicate key update when_updated=current_time, online_status = :online";
-    SqlUpdate sqlUpdate2 = Ebean.createSqlUpdate(sqlNamed)
+    SqlUpdate sqlUpdate2 = DB.sqlUpdate(sqlNamed)
       .setGetGeneratedKeys(true)
       .setParameter("email", email)
       .setParameter("online", false);
@@ -120,7 +119,7 @@ public class TestSqlUpdateUpsert extends BaseTestCase {
     sqlUpdate2.execute();
     Object key2 = sqlUpdate2.getGeneratedKey();
 
-    EPersonOnline found2 = Ebean.find(EPersonOnline.class, key2);
+    EPersonOnline found2 = DB.find(EPersonOnline.class, key2);
     assertThat(found2).isNotNull();
     assertThat(found2.getId().toString()).isEqualTo(key.toString());
     assertThat(found2.getEmail()).isEqualTo("bar@one.com");
diff --git a/ebean-core/src/test/java/org/tests/update/TestStatelessUpdate.java b/ebean-test/src/test/java/org/tests/update/TestStatelessUpdate.java
similarity index 94%
rename from ebean-core/src/test/java/org/tests/update/TestStatelessUpdate.java
rename to ebean-test/src/test/java/org/tests/update/TestStatelessUpdate.java
index d96de03e4..e8243bdd1 100644
--- a/ebean-core/src/test/java/org/tests/update/TestStatelessUpdate.java
+++ b/ebean-test/src/test/java/org/tests/update/TestStatelessUpdate.java
@@ -2,26 +2,18 @@ package org.tests.update;
 
 import io.ebean.DB;
 import io.ebean.TransactionalTestCase;
-import io.ebeantest.LoggedSql;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Contact;
 import org.tests.model.basic.Customer;
 import org.tests.model.basic.EBasic;
 import org.tests.model.basic.EBasic.Status;
 
 import javax.persistence.EntityNotFoundException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestStatelessUpdate extends TransactionalTestCase {
 
@@ -79,20 +71,18 @@ public class TestStatelessUpdate extends TransactionalTestCase {
     assertThat(sql.get(0)).contains("update e_basic set name=?, description=? where id=?; -- bind(updateWithNull,null,");
   }
 
-  @Test(expected = EntityNotFoundException.class)
+  @Test
   public void update_NoRowsUpdated_expect_EntityNotFoundException() {
-
     EBasic basic = new EBasic();
     basic.setId(999999999);
     basic.setName("something");
     basic.setStatus(Status.ACTIVE);
 
-    DB.update(basic);
+    assertThrows(EntityNotFoundException.class, () -> DB.update(basic));
   }
 
   @Test
   public void delete_NoRowsDeleted_expect_false() {
-
     EBasic basic = new EBasic();
     basic.setId(999999999);
     basic.setName("something");
@@ -189,7 +179,7 @@ public class TestStatelessUpdate extends TransactionalTestCase {
 
     // assert null list was ignored (missing children not deleted)
     assertNotNull(result.getContacts());
-    assertFalse("the contacts mustn't be deleted", result.getContacts().isEmpty());
+    assertFalse(result.getContacts().isEmpty());
     assertThat(sql).hasSize(1);
     assertThat(sql.get(0)).contains("update o_customer set name=?, updtime=? where id=?;");
   }
@@ -231,14 +221,13 @@ public class TestStatelessUpdate extends TransactionalTestCase {
 
     // assert empty bean list was ignore (missing children not deleted)
     assertNotNull(result.getContacts());
-    assertFalse("the contacts mustn't be deleted", result.getContacts().isEmpty());
+    assertFalse(result.getContacts().isEmpty());
     assertThat(sql).hasSize(1);
     assertThat(sql.get(0)).contains("update o_customer set name=?, updtime=? where id=?;");
   }
 
   @Test
   public void testStatelessUpdateDeleteChildrenForNonBeanCollection() {
-
     // arrange
     Contact contact = new Contact();
     contact.setFirstName("wobu :P");
@@ -272,7 +261,7 @@ public class TestStatelessUpdate extends TransactionalTestCase {
   }
 
   private boolean containsContacts(Customer cust) {
-    return DB.getBeanState(cust).getLoadedProps().contains("contacts");
+    return DB.beanState(cust).loadedProps().contains("contacts");
   }
 
   /**
diff --git a/ebean-core/src/test/java/org/tests/update/TestUpdateAllLoadedProperties.java b/ebean-test/src/test/java/org/tests/update/TestUpdateAllLoadedProperties.java
similarity index 77%
rename from ebean-core/src/test/java/org/tests/update/TestUpdateAllLoadedProperties.java
rename to ebean-test/src/test/java/org/tests/update/TestUpdateAllLoadedProperties.java
index 38c33c206..416e6f974 100644
--- a/ebean-core/src/test/java/org/tests/update/TestUpdateAllLoadedProperties.java
+++ b/ebean-test/src/test/java/org/tests/update/TestUpdateAllLoadedProperties.java
@@ -1,18 +1,18 @@
 package org.tests.update;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import io.ebean.EbeanServer;
+import io.ebean.DB;
+import io.ebean.Database;
 import io.ebean.Transaction;
-import org.ebeantest.LoggedSqlCollector;
-import org.junit.Test;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasicVer;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestUpdateAllLoadedProperties extends BaseTestCase {
 
@@ -21,19 +21,19 @@ public class TestUpdateAllLoadedProperties extends BaseTestCase {
 
     EBasicVer basic1 = new EBasicVer("basic1");
     basic1.setDescription("aaa");
-    Ebean.save(basic1);
+    DB.save(basic1);
 
     EBasicVer basic2 = new EBasicVer("basic2");
     basic1.setDescription("bbb");
-    Ebean.save(basic2);
+    DB.save(basic2);
 
 
-    EbeanServer server = Ebean.getDefaultServer();
+    Database server = DB.getDefault();
     try (Transaction txn = server.beginTransaction()) {
 
       txn.setUpdateAllLoadedProperties(true);
 
-      LoggedSqlCollector.start();
+      LoggedSql.start();
 
       basic2.setDescription("bbb-mod");
       server.save(basic2, txn);
@@ -44,7 +44,7 @@ public class TestUpdateAllLoadedProperties extends BaseTestCase {
 
       txn.commit();
 
-      List<String> loggedSql = LoggedSqlCollector.stop();
+      List<String> loggedSql = LoggedSql.stop();
 
       assertEquals(2, loggedSql.size());
       // all properties in the bean
@@ -62,7 +62,7 @@ public class TestUpdateAllLoadedProperties extends BaseTestCase {
     ids.add(id1);
     ids.add(id2);
 
-    List<EBasicVer> beans = Ebean.find(EBasicVer.class)
+    List<EBasicVer> beans = DB.find(EBasicVer.class)
       .select("name, other")
       .where().idIn(ids)
       .order().asc("id")
@@ -70,21 +70,21 @@ public class TestUpdateAllLoadedProperties extends BaseTestCase {
 
     assertEquals(2, beans.size());
 
-    LoggedSqlCollector.start();
+    LoggedSql.start();
 
 
-    Transaction txn = Ebean.beginTransaction();
+    Transaction txn = DB.beginTransaction();
     try {
       txn.setUpdateAllLoadedProperties(true);
 
       EBasicVer basic1 = beans.get(0);
       basic1.setName("jim");
-      Ebean.save(basic1);
+      DB.save(basic1);
 
       EBasicVer basic2 = beans.get(1);
       basic2.setName("john");
       basic2.setOther("otherDesc");
-      Ebean.save(basic2);
+      DB.save(basic2);
 
       txn.commit();
 
@@ -92,7 +92,7 @@ public class TestUpdateAllLoadedProperties extends BaseTestCase {
       txn.end();
     }
 
-    List<String> loggedSql = LoggedSqlCollector.stop();
+    List<String> loggedSql = LoggedSql.stop();
 
     assertThat(loggedSql).hasSize(2);
     assertThat(loggedSql.get(0)).contains("update e_basicver set name=?, other=? where id=?; -- bind(");
diff --git a/ebean-core/src/test/java/org/tests/update/TestUpdateCircularSave.java b/ebean-test/src/test/java/org/tests/update/TestUpdateCircularSave.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/update/TestUpdateCircularSave.java
rename to ebean-test/src/test/java/org/tests/update/TestUpdateCircularSave.java
index b32046435..cfdd8b1cf 100644
--- a/ebean-core/src/test/java/org/tests/update/TestUpdateCircularSave.java
+++ b/ebean-test/src/test/java/org/tests/update/TestUpdateCircularSave.java
@@ -1,16 +1,16 @@
 package org.tests.update;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
-import org.junit.Ignore;
-import org.junit.Test;
+import io.ebean.DB;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.tests.update.objects.Child;
 import org.tests.update.objects.Parent;
 import org.tests.update.objects.SiblingA;
 import org.tests.update.objects.SiblingB;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class TestUpdateCircularSave extends BaseTestCase {
 
@@ -20,19 +20,19 @@ public class TestUpdateCircularSave extends BaseTestCase {
     long aId = createA();
     modifyPropertyToTrue(aId);
 
-    SiblingA siblingA = Ebean.find(SiblingA.class, aId);
+    SiblingA siblingA = DB.find(SiblingA.class, aId);
     assert siblingA != null;
     assertTrue(siblingA.getSiblingB().isTestProperty());
   }
 
   private void modifyPropertyToTrue(long aId) {
-    SiblingA siblingA = Ebean.find(SiblingA.class, aId);
+    SiblingA siblingA = DB.find(SiblingA.class, aId);
     assert siblingA != null;
 
     final SiblingB siblingB = siblingA.getSiblingB();
     siblingB.setTestProperty(true);
     // Will get optimistic lock as version is increased twice on B
-    Ebean.save(siblingB);
+    DB.save(siblingB);
   }
 
   private long createA() {
@@ -40,28 +40,28 @@ public class TestUpdateCircularSave extends BaseTestCase {
     SiblingB siblingB = new SiblingB();
     siblingA.setSiblingB(siblingB);
 
-    Ebean.save(siblingA);
+    DB.save(siblingA);
     return siblingA.getId();
   }
 
-  @Ignore
+  @Disabled
   @Test
   public void testFetchChildModifyChildSaveParent() {
 
     long childId = createParentAndChild().getChild().getId();
 
-    Child child = Ebean.find(Child.class, childId);
+    Child child = DB.find(Child.class, childId);
     assert child != null;
 
     child.setTestProperty(true);
     final Parent parent = child.getParent();
-    Ebean.save(parent);
+    DB.save(parent);
 
     assertChildModified(childId);
   }
 
   private void assertChildModified(long childId) {
-    Parent parent = Ebean.find(Parent.class, childId);
+    Parent parent = DB.find(Parent.class, childId);
     assert parent != null;
     // Fails here because D was not saved even though C has cascade = ALL
     assertTrue(parent.getChild().isTestProperty());
@@ -73,7 +73,7 @@ public class TestUpdateCircularSave extends BaseTestCase {
     Child child = new Child();
     parent.setChild(child);
 
-    Ebean.save(parent);
+    DB.save(parent);
     return parent;
   }
 
@@ -82,11 +82,11 @@ public class TestUpdateCircularSave extends BaseTestCase {
   public void testFetchParentModifyChildSaveParent() {
     long parentId = createParentAndChild().getId();
 
-    Parent parent = Ebean.find(Parent.class, parentId);
+    Parent parent = DB.find(Parent.class, parentId);
     assert parent != null;
 
     parent.getChild().setTestProperty(true);
-    Ebean.save(parent);
+    DB.save(parent);
 
     assertChildModified(parent.getChild().getId());
   }
diff --git a/ebean-core/src/test/java/org/tests/update/TestUpdatePartial.java b/ebean-test/src/test/java/org/tests/update/TestUpdatePartial.java
similarity index 76%
rename from ebean-core/src/test/java/org/tests/update/TestUpdatePartial.java
rename to ebean-test/src/test/java/org/tests/update/TestUpdatePartial.java
index ac1085896..978ef0589 100644
--- a/ebean-core/src/test/java/org/tests/update/TestUpdatePartial.java
+++ b/ebean-test/src/test/java/org/tests/update/TestUpdatePartial.java
@@ -2,13 +2,12 @@ package org.tests.update;
 
 import io.ebean.BaseTestCase;
 import io.ebean.DB;
-import io.ebean.Ebean;
 import io.ebean.SqlRow;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.Customer;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class TestUpdatePartial extends BaseTestCase {
 
@@ -20,10 +19,10 @@ public class TestUpdatePartial extends BaseTestCase {
     c.setStatus(Customer.Status.ACTIVE);
     c.setSmallnote("a note");
 
-    Ebean.save(c);
+    DB.save(c);
     checkDbStatusValue(c.getId(), "A");
 
-    Customer c2 = Ebean.find(Customer.class)
+    Customer c2 = DB.find(Customer.class)
       .setUseCache(false)
       .select("status, smallnote")
       .setId(c.getId())
@@ -32,10 +31,10 @@ public class TestUpdatePartial extends BaseTestCase {
     c2.setStatus(Customer.Status.INACTIVE);
     c2.setSmallnote("2nd note");
 
-    Ebean.save(c2);
+    DB.save(c2);
     checkDbStatusValue(c.getId(), "I");
 
-    Customer c3 = Ebean.find(Customer.class)
+    Customer c3 = DB.find(Customer.class)
       .setUseCache(false)
       .select("status")
       .setId(c.getId())
@@ -44,11 +43,11 @@ public class TestUpdatePartial extends BaseTestCase {
     c3.setStatus(Customer.Status.NEW);
     c3.setSmallnote("3rd note");
 
-    Ebean.save(c3);
+    DB.save(c3);
     checkDbStatusValue(c.getId(), "N");
 
     // cleanup
-    Ebean.delete(Customer.class, c.getId());
+    DB.delete(Customer.class, c.getId());
   }
 
   private void checkDbStatusValue(Integer custId, String dbStatus) {
@@ -68,15 +67,15 @@ public class TestUpdatePartial extends BaseTestCase {
     Customer customer = new Customer();
     customer.setName("something");
 
-    Ebean.save(customer);
+    DB.save(customer);
 
-    Customer customerWithoutChanges = Ebean.find(Customer.class, customer.getId());
-    Ebean.save(customerWithoutChanges);
+    Customer customerWithoutChanges = DB.find(Customer.class, customer.getId());
+    DB.save(customerWithoutChanges);
 
     assertThat(customerWithoutChanges.getUpdtime()).isEqualToIgnoringMillis(customer.getUpdtime());
 
     // cleanup
-    Ebean.delete(customerWithoutChanges);
+    DB.delete(customerWithoutChanges);
 
   }
 }
diff --git a/ebean-core/src/test/java/org/tests/update/TestUpdatePartialNoVer.java b/ebean-test/src/test/java/org/tests/update/TestUpdatePartialNoVer.java
similarity index 68%
rename from ebean-core/src/test/java/org/tests/update/TestUpdatePartialNoVer.java
rename to ebean-test/src/test/java/org/tests/update/TestUpdatePartialNoVer.java
index 181b0ede0..0af27a760 100644
--- a/ebean-core/src/test/java/org/tests/update/TestUpdatePartialNoVer.java
+++ b/ebean-test/src/test/java/org/tests/update/TestUpdatePartialNoVer.java
@@ -1,10 +1,10 @@
 package org.tests.update;
 
 import io.ebean.BaseTestCase;
-import io.ebean.Ebean;
+import io.ebean.DB;
+import org.junit.jupiter.api.Test;
 import org.tests.model.basic.EBasic;
 import org.tests.model.basic.EBasic.Status;
-import org.junit.Test;
 
 public class TestUpdatePartialNoVer extends BaseTestCase {
 
@@ -16,13 +16,13 @@ public class TestUpdatePartialNoVer extends BaseTestCase {
     b.setStatus(Status.ACTIVE);
     b.setDescription("description");
 
-    Ebean.save(b);
+    DB.save(b);
 
-    EBasic basic = Ebean.find(EBasic.class).select("status, name").setId(b.getId()).findOne();
+    EBasic basic = DB.find(EBasic.class).select("status, name").setId(b.getId()).findOne();
 
     basic.setName("modiName");
 
-    Ebean.save(basic);
+    DB.save(basic);
 
   }
 
diff --git a/ebean-core/src/test/java/org/tests/update/objects/Child.java b/ebean-test/src/test/java/org/tests/update/objects/Child.java
similarity index 82%
rename from ebean-core/src/test/java/org/tests/update/objects/Child.java
rename to ebean-test/src/test/java/org/tests/update/objects/Child.java
index b8a91a2b7..87166bfda 100644
--- a/ebean-core/src/test/java/org/tests/update/objects/Child.java
+++ b/ebean-test/src/test/java/org/tests/update/objects/Child.java
@@ -1,10 +1,6 @@
 package org.tests.update.objects;
 
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "e_save_test_d")
diff --git a/ebean-core/src/test/java/org/tests/update/objects/Parent.java b/ebean-test/src/test/java/org/tests/update/objects/Parent.java
similarity index 74%
rename from ebean-core/src/test/java/org/tests/update/objects/Parent.java
rename to ebean-test/src/test/java/org/tests/update/objects/Parent.java
index bdcfa58f9..6a582a981 100644
--- a/ebean-core/src/test/java/org/tests/update/objects/Parent.java
+++ b/ebean-test/src/test/java/org/tests/update/objects/Parent.java
@@ -1,11 +1,6 @@
 package org.tests.update.objects;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "e_save_test_c")
diff --git a/ebean-core/src/test/java/org/tests/update/objects/SiblingA.java b/ebean-test/src/test/java/org/tests/update/objects/SiblingA.java
similarity index 75%
rename from ebean-core/src/test/java/org/tests/update/objects/SiblingA.java
rename to ebean-test/src/test/java/org/tests/update/objects/SiblingA.java
index 2e5806657..71fb72816 100644
--- a/ebean-core/src/test/java/org/tests/update/objects/SiblingA.java
+++ b/ebean-test/src/test/java/org/tests/update/objects/SiblingA.java
@@ -1,11 +1,6 @@
 package org.tests.update.objects;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "e_save_test_a")
diff --git a/ebean-core/src/test/java/org/tests/update/objects/SiblingB.java b/ebean-test/src/test/java/org/tests/update/objects/SiblingB.java
similarity index 80%
rename from ebean-core/src/test/java/org/tests/update/objects/SiblingB.java
rename to ebean-test/src/test/java/org/tests/update/objects/SiblingB.java
index 63b358645..cbd32a7fb 100644
--- a/ebean-core/src/test/java/org/tests/update/objects/SiblingB.java
+++ b/ebean-test/src/test/java/org/tests/update/objects/SiblingB.java
@@ -1,11 +1,6 @@
 package org.tests.update.objects;
 
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.OneToOne;
-import javax.persistence.Table;
-import javax.persistence.Version;
+import javax.persistence.*;
 
 @Entity
 @Table(name = "e_save_test_b")
diff --git a/ebean-core/src/test/resources/EQL.g4 b/ebean-test/src/test/resources/EQL.g4
similarity index 100%
rename from ebean-core/src/test/resources/EQL.g4
rename to ebean-test/src/test/resources/EQL.g4
diff --git a/ebean-core/src/test/resources/META-INF/test/test-agent-only-use.mf b/ebean-test/src/test/resources/META-INF/test/test-agent-only-use.mf
similarity index 100%
rename from ebean-core/src/test/resources/META-INF/test/test-agent-only-use.mf
rename to ebean-test/src/test/resources/META-INF/test/test-agent-only-use.mf
diff --git a/ebean-core/src/test/resources/META-INF/test/test-combined.mf b/ebean-test/src/test/resources/META-INF/test/test-combined.mf
similarity index 100%
rename from ebean-core/src/test/resources/META-INF/test/test-combined.mf
rename to ebean-test/src/test/resources/META-INF/test/test-combined.mf
diff --git a/ebean-core/src/test/resources/META-INF/test/test-entity-packages.mf b/ebean-test/src/test/resources/META-INF/test/test-entity-packages.mf
similarity index 100%
rename from ebean-core/src/test/resources/META-INF/test/test-entity-packages.mf
rename to ebean-test/src/test/resources/META-INF/test/test-entity-packages.mf
diff --git a/ebean-core/src/test/resources/META-INF/test/test-one.mf b/ebean-test/src/test/resources/META-INF/test/test-one.mf
similarity index 100%
rename from ebean-core/src/test/resources/META-INF/test/test-one.mf
rename to ebean-test/src/test/resources/META-INF/test/test-one.mf
diff --git a/ebean-core/src/test/resources/META-INF/test/test-some.mf b/ebean-test/src/test/resources/META-INF/test/test-some.mf
similarity index 100%
rename from ebean-core/src/test/resources/META-INF/test/test-some.mf
rename to ebean-test/src/test/resources/META-INF/test/test-some.mf
diff --git a/ebean-core/src/test/resources/docker-run.properties b/ebean-test/src/test/resources/docker-run.properties
similarity index 100%
rename from ebean-core/src/test/resources/docker-run.properties
rename to ebean-test/src/test/resources/docker-run.properties
diff --git a/ebean-test/src/test/resources/ebean.mf b/ebean-test/src/test/resources/ebean.mf
index 86b6aa821..fc2fd6902 100644
--- a/ebean-test/src/test/resources/ebean.mf
+++ b/ebean-test/src/test/resources/ebean.mf
@@ -1,2 +1,7 @@
-entity-packages: org.test
-transactional-packages: org.test
+agent-use-only: true
+profile-location: true
+entity-packages: org,misc
+transactional-packages: org
+querybean-packages: none
+synthetic: true
+
diff --git a/ebean-core/src/test/resources/ebean.properties b/ebean-test/src/test/resources/ebean.properties
similarity index 99%
rename from ebean-core/src/test/resources/ebean.properties
rename to ebean-test/src/test/resources/ebean.properties
index 49aae2a31..0fc9586f9 100644
--- a/ebean-core/src/test/resources/ebean.properties
+++ b/ebean-test/src/test/resources/ebean.properties
@@ -21,7 +21,7 @@ ebean.encryptKeyManager=org.tests.basic.encrypt.BasicEncyptKeyManager
 ebean.ddl.generate=true
 ebean.ddl.run=true
 ebean.ddl.header=-- Generated by ebean ${version} at ${timestamp}
-ebean.packages=org.tests
+ebean.packages=org.tests,org.etest
 datasource.default=h2
 #datasource.h2.capturestacktrace=true
 
diff --git a/ebean-core/src/test/resources/example1.json b/ebean-test/src/test/resources/example1.json
similarity index 100%
rename from ebean-core/src/test/resources/example1.json
rename to ebean-test/src/test/resources/example1.json
diff --git a/ebean-core/src/test/resources/extra-ddl.xml b/ebean-test/src/test/resources/extra-ddl.xml
similarity index 100%
rename from ebean-core/src/test/resources/extra-ddl.xml
rename to ebean-test/src/test/resources/extra-ddl.xml
diff --git a/ebean-core/src/test/resources/java-64.png b/ebean-test/src/test/resources/java-64.png
similarity index 100%
rename from ebean-core/src/test/resources/java-64.png
rename to ebean-test/src/test/resources/java-64.png
diff --git a/ebean-core/src/test/resources/junk.json b/ebean-test/src/test/resources/junk.json
similarity index 100%
rename from ebean-core/src/test/resources/junk.json
rename to ebean-test/src/test/resources/junk.json
diff --git a/ebean-test/src/test/resources/logback-test.xml b/ebean-test/src/test/resources/logback-test.xml
index ce7ad5968..bfe4a1ede 100644
--- a/ebean-test/src/test/resources/logback-test.xml
+++ b/ebean-test/src/test/resources/logback-test.xml
@@ -1,22 +1,99 @@
 <configuration scan="true" scanPeriod="10 seconds">
   <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>TRACE</level>
+    </filter>
     <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
       <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
     </encoder>
   </appender>
 
-  <root level="INFO">
+  <appender name="APPLICATION" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <File>target/log/application.log</File>
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>TRACE</level>
+    </filter>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <FileNamePattern>log/application.log.%d{yyyy-MM-dd}</FileNamePattern>
+      <MaxHistory>90</MaxHistory>
+    </rollingPolicy>
+    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <appender name="READAUDIT_QUERY_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <File>target/log/readAuditQuery.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <FileNamePattern>log/readAuditQuery.log.%d{yyyy-MM-dd}</FileNamePattern>
+      <MaxHistory>90</MaxHistory>
+    </rollingPolicy>
+    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+      <pattern>%d{HH:mm:ss.SSS} %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <appender name="READAUDIT_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <File>target/log/readAudit.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <FileNamePattern>log/readAudit.log.%d{yyyy-MM-dd}</FileNamePattern>
+      <MaxHistory>90</MaxHistory>
+    </rollingPolicy>
+    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+      <pattern>%d{HH:mm:ss.SSS} %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <appender name="CHANGE_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <File>target/log/change-log.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <FileNamePattern>log/changeLog.log.%d{yyyy-MM-dd}</FileNamePattern>
+      <MaxHistory>90</MaxHistory>
+    </rollingPolicy>
+    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+      <pattern>%d{HH:mm:ss.SSS} %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="io.ebean.ReadAuditQuery" level="TRACE" additivity="false">
+    <appender-ref ref="READAUDIT_QUERY_LOG"/>
+  </logger>
+
+  <logger name="io.ebean.ReadAudit" level="TRACE" additivity="false">
+    <appender-ref ref="READAUDIT_LOG"/>
+  </logger>
+
+  <logger name="io.ebean.ChangeLog" level="TRACE" additivity="false">
+    <appender-ref ref="CHANGE_LOG"/>
+  </logger>
+
+  <root level="WARN">
+    <appender-ref ref="APPLICATION"/>
     <appender-ref ref="STDOUT"/>
   </root>
 
-  <logger name="org.avaje" level="TRACE"/>
+
+  <logger name="org.tests" level="INFO"/>
   <logger name="io.ebean" level="INFO"/>
 
   <logger name="io.ebean.docker" level="TRACE"/>
-  <logger name="io.ebean.DDL" level="DEBUG"/>
+<!--  <logger name="io.ebean.DDL" level="DEBUG"/>-->
 
-  <logger name="io.ebean.SQL" level="TRACE"/>
-  <logger name="io.ebean.TXN" level="TRACE"/>
-  <logger name="io.ebean.SUM" level="TRACE"/>
+<!--  <logger name="io.ebean.SQL" level="TRACE"/>-->
+<!--  <logger name="io.ebean.TXN" level="TRACE"/>-->
+<!--  <logger name="io.ebean.SUM" level="TRACE"/>-->
+
+<!--  <logger name="io.ebean.cache" level="TRACE"/>-->
+<!--  <logger name="io.ebean.cache.REGION" level="TRACE"/>-->
+<!--  <logger name="io.ebean.cache.TABLEMOD" level="TRACE"/>-->
+
+<!--  <logger name="io.ebean.cache.QUERY" level="TRACE"/>-->
+<!--  <logger name="io.ebean.cache.BEAN" level="TRACE"/>-->
+<!--  <logger name="io.ebean.cache.NATKEY" level="TRACE"/>-->
+<!--  <logger name="io.ebean.cache.COLL" level="TRACE"/>-->
+
+<!--  <logger name="io.avaje.classpath" level="TRACE"/>-->
+  <!--<logger name="io.ebeaninternal.server.autotune" level="TRACE"/>-->
+  <!--<logger name="io.ebean.ChangeLog" level="INFO"/>-->
 
 </configuration>
diff --git a/ebean-test/src/test/resources/application-test.yaml b/ebean-test/src/test/resources/notused-application-test.yaml
similarity index 100%
rename from ebean-test/src/test/resources/application-test.yaml
rename to ebean-test/src/test/resources/notused-application-test.yaml
diff --git a/ebean-core/src/test/resources/profile-image.jpg b/ebean-test/src/test/resources/profile-image.jpg
similarity index 100%
rename from ebean-core/src/test/resources/profile-image.jpg
rename to ebean-test/src/test/resources/profile-image.jpg
diff --git a/ebean-core/src/test/resources/scripts/test-script-2.sql b/ebean-test/src/test/resources/scripts/test-script-2.sql
similarity index 100%
rename from ebean-core/src/test/resources/scripts/test-script-2.sql
rename to ebean-test/src/test/resources/scripts/test-script-2.sql
diff --git a/ebean-core/src/test/resources/scripts/test-script.sql b/ebean-test/src/test/resources/scripts/test-script.sql
similarity index 100%
rename from ebean-core/src/test/resources/scripts/test-script.sql
rename to ebean-test/src/test/resources/scripts/test-script.sql
diff --git a/ebean-core/src/test/resources/test-ebean.properties b/ebean-test/src/test/resources/test-ebean.properties
similarity index 100%
rename from ebean-core/src/test/resources/test-ebean.properties
rename to ebean-test/src/test/resources/test-ebean.properties
diff --git a/ebean-core/src/test/resources/test-properties/application.properties b/ebean-test/src/test/resources/test-properties/application.properties
similarity index 100%
rename from ebean-core/src/test/resources/test-properties/application.properties
rename to ebean-test/src/test/resources/test-properties/application.properties
diff --git a/ebean-core/src/test/resources/test-properties/application.yaml b/ebean-test/src/test/resources/test-properties/application.yaml
similarity index 100%
rename from ebean-core/src/test/resources/test-properties/application.yaml
rename to ebean-test/src/test/resources/test-properties/application.yaml
diff --git a/ebean-core/src/test/resources/test-properties/foo.yml b/ebean-test/src/test/resources/test-properties/foo.yml
similarity index 100%
rename from ebean-core/src/test/resources/test-properties/foo.yml
rename to ebean-test/src/test/resources/test-properties/foo.yml
diff --git a/ebean-core/src/test/resources/test-properties/one.properties b/ebean-test/src/test/resources/test-properties/one.properties
similarity index 100%
rename from ebean-core/src/test/resources/test-properties/one.properties
rename to ebean-test/src/test/resources/test-properties/one.properties
diff --git a/ebean-core/src/test/resources/test1.csv b/ebean-test/src/test/resources/test1.csv
similarity index 100%
rename from ebean-core/src/test/resources/test1.csv
rename to ebean-test/src/test/resources/test1.csv
diff --git a/ebean/pom.xml b/ebean/pom.xml
index b17e93449..5664c8f7f 100644
--- a/ebean/pom.xml
+++ b/ebean/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <name>ebean composite</name>
@@ -22,20 +22,20 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-api</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
     </dependency>
 
     <!-- Technically optional but most expected to use query beans -->
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-querybean</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
     </dependency>
 
   </dependencies>
diff --git a/kotlin-querybean-generator/pom.xml b/kotlin-querybean-generator/pom.xml
index 68601c019..a5aba2f05 100644
--- a/kotlin-querybean-generator/pom.xml
+++ b/kotlin-querybean-generator/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <name>kotlin querybean generator</name>
@@ -20,16 +20,16 @@
     <!-- test dependencies -->
 
     <dependency>
-      <groupId>org.avaje.composite</groupId>
+      <groupId>io.avaje</groupId>
       <artifactId>junit</artifactId>
-      <version>5.0</version>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-querybean</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
@@ -43,7 +43,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
@@ -64,14 +64,14 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-ddl-generator</artifactId>
-      <version>12.11.2-SNAPSHOT</version>
+      <version>12.11.5-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>javax.validation</groupId>
       <artifactId>validation-api</artifactId>
-      <version>1.1.0.Final</version>
+      <version>2.0.1.Final</version>
       <scope>test</scope>
     </dependency>
 
diff --git a/kotlin-querybean-generator/src/main/java/io/ebean/querybean/generator/PropertyTypeMap.java b/kotlin-querybean-generator/src/main/java/io/ebean/querybean/generator/PropertyTypeMap.java
index 6afc8a6e3..28e78afa7 100644
--- a/kotlin-querybean-generator/src/main/java/io/ebean/querybean/generator/PropertyTypeMap.java
+++ b/kotlin-querybean-generator/src/main/java/io/ebean/querybean/generator/PropertyTypeMap.java
@@ -55,6 +55,7 @@ class PropertyTypeMap {
     map.put("java.lang.Class<?>", new PropertyType("PClass"));
     addType(Locale.class);
     addType(File.class);
+    map.put("byte[]", new PropertyType("PByteArray"));
     addType(InetAddress.class);
     map.put(URI.class.getName(), new PropertyType("PUri"));
     map.put(URL.class.getName(), new PropertyType("PUrl"));
diff --git a/pom.xml b/pom.xml
index 9e8ae831a..215bf59fa 100644
--- a/pom.xml
+++ b/pom.xml
@@ -9,7 +9,7 @@
 
   <groupId>io.ebean</groupId>
   <artifactId>ebean-parent</artifactId>
-  <version>12.11.2-SNAPSHOT</version>
+  <version>12.11.5-SNAPSHOT</version>
   <packaging>pom</packaging>
 
   <name>ebean parent</name>
@@ -18,7 +18,7 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-parent-12.8.0</tag>
+    <tag>ebean-parent-12.11.4</tag>
   </scm>
 
   <licenses>
@@ -66,9 +66,9 @@
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.composite</groupId>
-      <artifactId>junit</artifactId>
-      <version>1.1</version>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+      <version>1.4.199</version>
       <scope>test</scope>
     </dependency>
 
@@ -90,6 +90,7 @@
     <module>ebean-querybean</module>
     <module>ebean-postgis</module>
     <module>ebean-redis</module>
+    <!-- <module>tests</module> -->
   </modules>
 
 </project>
diff --git a/querybean-generator/pom.xml b/querybean-generator/pom.xml
index 1cf09f8be..59291dfdb 100644
--- a/querybean-generator/pom.xml
+++ b/querybean-generator/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2-SNAPSHOT</version>
+    <version>12.11.5-SNAPSHOT</version>
   </parent>
 
   <name>querybean generator</name>
@@ -14,9 +14,9 @@
   <dependencies>
 
     <dependency>
-      <groupId>org.avaje.composite</groupId>
-      <artifactId>composite-testing</artifactId>
-      <version>3.1</version>
+      <groupId>io.avaje</groupId>
+      <artifactId>junit</artifactId>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
diff --git a/querybean-generator/src/main/java/io/ebean/querybean/generator/PropertyTypeMap.java b/querybean-generator/src/main/java/io/ebean/querybean/generator/PropertyTypeMap.java
index fa35c72fa..848f37791 100644
--- a/querybean-generator/src/main/java/io/ebean/querybean/generator/PropertyTypeMap.java
+++ b/querybean-generator/src/main/java/io/ebean/querybean/generator/PropertyTypeMap.java
@@ -55,6 +55,7 @@ class PropertyTypeMap {
     addType(Locale.class);
     map.put("java.lang.Class<?>", new PropertyType("PClass"));
     addType(File.class);
+    map.put("byte[]", new PropertyType("PByteArray"));
     addType(InetAddress.class);
     map.put(URI.class.getName(), new PropertyType("PUri"));
     map.put(URL.class.getName(), new PropertyType("PUrl"));
diff --git a/querybean-generator/src/test/java/io/ebean/querybean/generator/SplitTest.java b/querybean-generator/src/test/java/io/ebean/querybean/generator/SplitTest.java
index 3ea80d6e3..96b89c582 100644
--- a/querybean-generator/src/test/java/io/ebean/querybean/generator/SplitTest.java
+++ b/querybean-generator/src/test/java/io/ebean/querybean/generator/SplitTest.java
@@ -1,24 +1,24 @@
 package io.ebean.querybean.generator;
 
+import org.junit.jupiter.api.Test;
+
 import static java.util.Arrays.asList;
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 import java.util.HashSet;
 
-import org.testng.annotations.Test;
-
 public class SplitTest {
 
   @Test
-  public void shortName() throws Exception {
+  public void shortName() {
 
     assertEquals(Split.shortName("com.foo.domain.Customer"), "Customer");
     assertEquals(Split.shortName("Customer"), "Customer");
   }
 
   @Test
-  public void split_normal() throws Exception {
+  public void split_normal() {
 
     String[] split = Split.split("com.foo.domain.Customer");
 
@@ -27,7 +27,7 @@ public class SplitTest {
   }
 
   @Test
-  public void split_noPackage() throws Exception {
+  public void split_noPackage() {
 
     String[] split = Split.split("Customer");
 
@@ -36,7 +36,7 @@ public class SplitTest {
   }
 
   @Test
-  public void split_generics() throws Exception {
+  public void split_generics() {
     assertEquals("Foo<Bar, XFoo<XBar>>", Split.genericsSplit("com.Foo<com.Bar, org.XFoo<org.XBar>>").getKey());
     assertEquals(new HashSet<>(asList("com.Foo", "com.Bar", "org.XFoo", "org.XBar")), Split.genericsSplit("com.Foo<com.Bar, org.XFoo<org.XBar>>").getValue());
   }
diff --git a/tests/test-java16/pom.xml b/tests/test-java16/pom.xml
index 21dfa7852..e3c81605e 100644
--- a/tests/test-java16/pom.xml
+++ b/tests/test-java16/pom.xml
@@ -19,7 +19,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean</artifactId>
-      <version>12.8.1-SNAPSHOT</version>
+      <version>12.11.4-SNAPSHOT</version>
     </dependency>
 
     <dependency>
@@ -31,14 +31,14 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-test</artifactId>
-      <version>12.8.1-SNAPSHOT</version>
+      <version>12.11.4-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.composite</groupId>
+      <groupId>io.avaje</groupId>
       <artifactId>junit</artifactId>
-      <version>5.0</version>
+      <version>1.0</version>
       <scope>test</scope>
     </dependency>
 
@@ -57,7 +57,7 @@
             <path>
               <groupId>io.ebean</groupId>
               <artifactId>querybean-generator</artifactId>
-              <version>12.8.1-SNAPSHOT</version>
+              <version>12.11.4-SNAPSHOT</version>
             </path>
           </annotationProcessorPaths>
         </configuration>
diff --git a/tests/test-java16/src/main/java/org/example/records/BaseModel.java b/tests/test-java16/src/main/java/org/example/records/BaseModel.java
index b5116e638..a2698576c 100644
--- a/tests/test-java16/src/main/java/org/example/records/BaseModel.java
+++ b/tests/test-java16/src/main/java/org/example/records/BaseModel.java
@@ -17,19 +17,19 @@ public class BaseModel extends Model {
   @Version
   long version;
 
-  public long getId() {
+  public long id() {
     return id;
   }
 
-  public void setId(long id) {
+  public void id(long id) {
     this.id = id;
   }
 
-  public long getVersion() {
+  public long version() {
     return version;
   }
 
-  public void setVersion(long version) {
+  public void version(long version) {
     this.version = version;
   }
 }
diff --git a/tests/test-java16/src/main/java/org/example/records/Contact.java b/tests/test-java16/src/main/java/org/example/records/Contact.java
index 871862f21..4b054511f 100644
--- a/tests/test-java16/src/main/java/org/example/records/Contact.java
+++ b/tests/test-java16/src/main/java/org/example/records/Contact.java
@@ -28,31 +28,31 @@ public class Contact extends Model {
     this.name = name;
   }
 
-  public String getName() {
+  public String name() {
     return name;
   }
 
-  public Address getHomeAddress() {
+  public Address homeAddress() {
     return homeAddress;
   }
 
-  public void setHomeAddress(Address homeAddress) {
+  public void homeAddress(Address homeAddress) {
     this.homeAddress = homeAddress;
   }
 
-  public Address getWorkAddress() {
+  public Address workAddress() {
     return workAddress;
   }
 
-  public void setWorkAddress(Address workAddress) {
+  public void workAddress(Address workAddress) {
     this.workAddress = workAddress;
   }
 
-  public long getId() {
+  public long id() {
     return id;
   }
 
-  public long getVersion() {
+  public long version() {
     return version;
   }
 }
diff --git a/tests/test-java16/src/main/java/org/example/records/Course.java b/tests/test-java16/src/main/java/org/example/records/Course.java
index 19e8d09fe..90e725416 100644
--- a/tests/test-java16/src/main/java/org/example/records/Course.java
+++ b/tests/test-java16/src/main/java/org/example/records/Course.java
@@ -19,15 +19,15 @@ public class Course extends BaseModel {
     this.name = name;
   }
 
-  public String getName() {
+  public String name() {
     return name;
   }
 
-  public String getSummary() {
+  public String summary() {
     return summary;
   }
 
-  public void setSummary(String summary) {
+  public void summary(String summary) {
     this.summary = summary;
   }
 }
diff --git a/tests/test-java16/src/main/java/org/example/records/UserRole.java b/tests/test-java16/src/main/java/org/example/records/UserRole.java
index 682e61f4a..1d25f6e97 100644
--- a/tests/test-java16/src/main/java/org/example/records/UserRole.java
+++ b/tests/test-java16/src/main/java/org/example/records/UserRole.java
@@ -22,15 +22,15 @@ public class UserRole extends Model {
     this.note = note;
   }
 
-  public UserRoleId getId() {
+  public UserRoleId id() {
     return id;
   }
 
-  public String getNote() {
+  public String note() {
     return note;
   }
 
-  public long getVersion() {
+  public long version() {
     return version;
   }
 }
diff --git a/tests/test-java16/src/main/java/org/example/records/UserSite.java b/tests/test-java16/src/main/java/org/example/records/UserSite.java
index a8cf46449..fb881c32e 100644
--- a/tests/test-java16/src/main/java/org/example/records/UserSite.java
+++ b/tests/test-java16/src/main/java/org/example/records/UserSite.java
@@ -25,27 +25,27 @@ public class UserSite extends Model {
     this.siteId = siteId;
   }
 
-  public UUID getUserId() {
+  public UUID userId() {
     return userId;
   }
 
-  public UUID getSiteId() {
+  public UUID siteId() {
     return siteId;
   }
 
-  public void setNote(String note) {
+  public void note(String note) {
     this.note = note;
   }
 
-  public void setVersion(long version) {
+  public void version(long version) {
     this.version = version;
   }
 
-  public String getNote() {
+  public String note() {
     return note;
   }
 
-  public long getVersion() {
+  public long version() {
     return version;
   }
 }
diff --git a/tests/test-java16/src/test/java/org/example/records/DtoQueryUsingRecordsTest.java b/tests/test-java16/src/test/java/org/example/records/DtoQueryUsingRecordsTest.java
index e64c15b1c..36c4a4fbf 100644
--- a/tests/test-java16/src/test/java/org/example/records/DtoQueryUsingRecordsTest.java
+++ b/tests/test-java16/src/test/java/org/example/records/DtoQueryUsingRecordsTest.java
@@ -16,7 +16,7 @@ class DtoQueryUsingRecordsTest {
   void dtoQuery_projectRecords() {
 
     var course = new Course("Calculus");
-    course.setSummary("Something here");
+    course.summary("Something here");
     course.save();
 
     performOrmQuery();
@@ -41,7 +41,7 @@ class DtoQueryUsingRecordsTest {
       .findList();
 
     assertThat(records).hasSize(1);
-    assertThat(records.get(0).name()).isEqualTo(course.getName());
+    assertThat(records.get(0).name()).isEqualTo(course.name());
   }
 
   private void records_via_OrmQueryToDtoQuery(Course course) {
@@ -52,7 +52,7 @@ class DtoQueryUsingRecordsTest {
       .findList();
 
     assertThat(records2).hasSize(1);
-    assertThat(records2.get(0).name()).isEqualTo(course.getName());
+    assertThat(records2.get(0).name()).isEqualTo(course.name());
   }
 
   public record Foo(long id, String name){}
diff --git a/tests/test-java16/src/test/java/org/example/records/RecordAsEmbeddedTest.java b/tests/test-java16/src/test/java/org/example/records/RecordAsEmbeddedTest.java
index 271481468..90cc1c5e4 100644
--- a/tests/test-java16/src/test/java/org/example/records/RecordAsEmbeddedTest.java
+++ b/tests/test-java16/src/test/java/org/example/records/RecordAsEmbeddedTest.java
@@ -13,36 +13,41 @@ public class RecordAsEmbeddedTest {
   void insert_query() {
 
     var contact = new Contact("Rob");
-    contact.setWorkAddress(new Address("45 work", "workling", "wo"));
-    contact.setHomeAddress(new Address("94 home st", "homeline", "wo"));
+    contact.workAddress(new Address("45 work", "workling", "wo"));
+    contact.homeAddress(new Address("94 home st", "homeline", "wo"));
 
     contact.save();
 
     Contact found = new QContact()
-      .id.eq(contact.getId())
+      .id.eq(contact.id())
       .findOne();
 
-    assertThat(found.getWorkAddress().toString()).isEqualTo("Address[line1=45 work, line2=workling, city=wo]");
-    assertThat(found.getHomeAddress().toString()).isEqualTo("Address[line1=94 home st, line2=homeline, city=wo]");
+    assert found != null;
+
+    assertThat(found.workAddress().toString()).isEqualTo("Address[line1=45 work, line2=workling, city=wo]");
+    assertThat(found.homeAddress().toString()).isEqualTo("Address[line1=94 home st, line2=homeline, city=wo]");
 
     Contact foundPartial = new QContact()
       .select(name, homeAddress)
-      .id.eq(contact.getId())
+      .id.eq(contact.id())
       .findOne();
 
-    // invoke lazy loading on getWorkAddress
-    assertThat(foundPartial.getWorkAddress().toString()).isEqualTo("Address[line1=45 work, line2=workling, city=wo]");
-    assertThat(foundPartial.getHomeAddress().toString()).isEqualTo("Address[line1=94 home st, line2=homeline, city=wo]");
+    assert foundPartial != null;
+
+    // invoke lazy loading on workAddress
+    assertThat(foundPartial.workAddress().toString()).isEqualTo("Address[line1=45 work, line2=workling, city=wo]");
+    assertThat(foundPartial.homeAddress().toString()).isEqualTo("Address[line1=94 home st, line2=homeline, city=wo]");
 
     Contact foundNoLazyLoading = new QContact()
       .select(name, homeAddress)
       .setDisableLazyLoading(true)
-      .id.eq(contact.getId())
+      .id.eq(contact.id())
       .findOne();
 
-    // no lazy loading on getWorkAddress this time
-    assertThat(foundNoLazyLoading.getWorkAddress()).isNull();
-    assertThat(foundNoLazyLoading.getHomeAddress().toString()).isEqualTo("Address[line1=94 home st, line2=homeline, city=wo]");
+    assert foundNoLazyLoading != null;
+    // no lazy loading on workAddress this time
+    assertThat(foundNoLazyLoading.workAddress()).isNull();
+    assertThat(foundNoLazyLoading.homeAddress().toString()).isEqualTo("Address[line1=94 home st, line2=homeline, city=wo]");
 
   }
 }
diff --git a/tests/test-java16/src/test/java/org/example/records/RecordIdClassTest.java b/tests/test-java16/src/test/java/org/example/records/RecordIdClassTest.java
index 47008c544..28696b6a2 100644
--- a/tests/test-java16/src/test/java/org/example/records/RecordIdClassTest.java
+++ b/tests/test-java16/src/test/java/org/example/records/RecordIdClassTest.java
@@ -16,7 +16,7 @@ class RecordIdClassTest {
     UUID siteId = UUID.randomUUID();
 
     var userSite = new UserSite(userId, siteId);
-    userSite.setNote("HelloIdClass");
+    userSite.note("HelloIdClass");
     userSite.save();
 
     var id = new UserSiteId(userId, siteId);
@@ -25,10 +25,20 @@ class RecordIdClassTest {
       .setId(id)
       .findOne();
 
-    assertThat(found.getUserId()).isEqualTo(userId);
-    assertThat(found.getSiteId()).isEqualTo(siteId);
-    assertThat(found.getNote()).isEqualTo("HelloIdClass");
+    assert found != null;
+    assertThat(found.userId()).isEqualTo(userId);
+    assertThat(found.siteId()).isEqualTo(siteId);
+    assertThat(found.note()).isEqualTo("HelloIdClass");
 
+    // again but using the scalar id properties
+    UserSite found2 = new QUserSite()
+      .siteId.eq(id.siteId())
+      .userId.eq(id.userId())
+      .findOne();
 
+    assert found2 != null;
+    assertThat(found2.userId()).isEqualTo(userId);
+    assertThat(found2.siteId()).isEqualTo(siteId);
+    assertThat(found2.note()).isEqualTo("HelloIdClass");
   }
 }
diff --git a/tests/test-java16/src/test/java/org/example/records/UserRoleTest.java b/tests/test-java16/src/test/java/org/example/records/UserRoleTest.java
index 1b4231b58..3f2e4a150 100644
--- a/tests/test-java16/src/test/java/org/example/records/UserRoleTest.java
+++ b/tests/test-java16/src/test/java/org/example/records/UserRoleTest.java
@@ -30,7 +30,7 @@ class UserRoleTest {
       .id.eq(new UserRoleId(42, "R7"))
       .findOne();
 
-    UserRoleId id1 = found.getId();
+    UserRoleId id1 = found.id();
     assertThat(id1).isEqualTo(id);
     assertThat(id1.userId()).isEqualTo(42);
     assertThat(id1.roleId()).isEqualTo("R7");