#919 - io.ebean package initial

src/test/java/org/tests/basic/MainDbBoolean.java

@@ -0,0 +1,154 @@
+package org.tests.basic;
+
+import io.ebean.EbeanServer;
+import io.ebean.EbeanServerFactory;
+import io.ebean.Query;
+import io.ebean.SqlRow;
+import io.ebean.config.ServerConfig;
+import io.ebean.config.dbplatform.postgres.PostgresPlatform;
+import org.tests.model.basic.TOne;
+import org.tests.model.basic.TSDetail;
+import org.tests.model.basic.TSMaster;
+import org.avaje.datasource.DataSourceConfig;
+import org.junit.Assert;
+
+import java.util.List;
+
+/**
+ * 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();
+    me.simpleCheck(server);
+
+    EbeanServer oraServer = me.createOracleEbeanServer();
+    me.simpleCheck(oraServer);
+  }
+
+  /**
+   * Create a server for running small oracle specific tests manually.
+   * DDL generation etc.
+   */
+  private EbeanServer createOracleEbeanServer() {
+
+    System.setProperty("ebean.ignoreExtraDdl", "true");
+
+    ServerConfig c = new ServerConfig();
+    c.setName("ora");
+
+    // requires oracle driver in class path
+    DataSourceConfig oraDb = new DataSourceConfig();
+    oraDb.setDriver("oracle.jdbc.driver.OracleDriver");
+    oraDb.setUsername("junk");
+    oraDb.setPassword("junk");
+    oraDb.setUrl("jdbc:oracle:thin:junk/junk@localhost:1521:XE");
+    oraDb.setHeartbeatSql("select count(*) from dual");
+
+
+    c.loadFromProperties();
+    c.setDdlGenerate(true);
+    c.setDdlRun(true);
+    c.setDefaultServer(false);
+    c.setRegister(false);
+    c.setDataSourceConfig(oraDb);
+
+    //c.setDatabaseBooleanTrue("1");
+    //c.setDatabaseBooleanFalse("0");
+    c.setDatabaseBooleanTrue("T");
+    c.setDatabaseBooleanFalse("F");
+
+    c.addClass(TOne.class);
+    c.addClass(TSMaster.class);
+    c.addClass(TSDetail.class);
+
+    return EbeanServerFactory.create(c);
+
+  }
+
+  private EbeanServer createEbeanServer() {
+
+    System.setProperty("ebean.ignoreExtraDdl", "true");
+
+    ServerConfig c = new ServerConfig();
+    c.setName("pgtest");
+
+    // requires postgres driver in class path
+    DataSourceConfig postgresDb = new DataSourceConfig();
+    postgresDb.setDriver("org.postgresql.Driver");
+    postgresDb.setUsername("test");
+    postgresDb.setPassword("test");
+    postgresDb.setUrl("jdbc:postgresql://127.0.0.1:5432/test");
+    postgresDb.setHeartbeatSql("select count(*) from t_one");
+
+    c.loadFromProperties();
+    c.setDdlGenerate(true);
+    c.setDdlRun(true);
+    c.setDefaultServer(false);
+    c.setRegister(false);
+    c.setDataSourceConfig(postgresDb);
+
+    //c.setDatabaseBooleanTrue("1");
+    //c.setDatabaseBooleanFalse("0");
+    c.setDatabaseBooleanTrue("T");
+    c.setDatabaseBooleanFalse("F");
+
+    c.setDatabasePlatform(new PostgresPlatform());
+
+    c.addClass(TOne.class);
+
+    return EbeanServerFactory.create(c);
+
+  }
+
+  private void simpleCheck(EbeanServer server) {
+
+    TOne o = new TOne();
+    o.setName("banan");
+    o.setDescription("this one is true");
+    o.setActive(true);
+
+    server.save(o);
+
+    TOne o2 = new TOne();
+    o2.setName("banan");
+    o2.setDescription("this one is false");
+    o2.setActive(false);
+
+    server.save(o2);
+
+
+    List<TOne> list = server.find(TOne.class)
+      .setAutoTune(false)
+      .order("id")
+      .findList();
+
+    Assert.assertTrue(list.size() == 2);
+    Assert.assertTrue(list.get(0).isActive());
+    Assert.assertFalse(!list.get(0).isActive());
+
+    String sql = "select id, name, active from t_oneb order by id";
+    List<SqlRow> sqlRows = server.createSqlQuery(sql).findList();
+    Assert.assertTrue(sqlRows.size() == 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));
+
+
+    Query<TOne> query = server.find(TOne.class)
+      .setAutoTune(false)
+      .order("id");
+
+    int rc = query.findCount();
+    Assert.assertTrue(rc > 0);
+
+
+    System.out.println("done");
+  }
+}

src/test/java/org/tests/basic/MyTestDataSourcePoolListener.java

@@ -0,0 +1,22 @@
+package org.tests.basic;
+
+import org.avaje.datasource.DataSourcePoolListener;
+
+import java.sql.Connection;
+
+public class MyTestDataSourcePoolListener implements DataSourcePoolListener {
+  public static int SLEEP_AFTER_BORROW = 0;
+
+  public void onAfterBorrowConnection(Connection c) {
+    if (SLEEP_AFTER_BORROW > 0) {
+      try {
+        Thread.sleep(SLEEP_AFTER_BORROW);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  public void onBeforeReturnConnection(Connection c) {
+  }
+}

src/test/java/org/tests/basic/TestAnnotationBase.java

@@ -0,0 +1,194 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.annotation.EbeanDDL;
+import io.ebean.annotation.Where;
+import io.ebean.Platform;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanProperty;
+import io.ebeaninternal.server.deploy.parse.AnnotationBase;
+import org.tests.model.basic.ValidationGroupSomething;
+import org.junit.Test;
+
+import javax.persistence.Entity;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Size;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+
+public class TestAnnotationBase extends BaseTestCase {
+
+  @Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
+  @Retention(RetentionPolicy.RUNTIME)
+  @Where(clause = "SELECT 'mysql' from 1", platforms = Platform.MYSQL)
+  @Where(clause = "SELECT 'h2' from 1", platforms = Platform.H2)
+  @Where(clause = "SELECT 'other' from 1")
+  public @interface MetaTest {
+
+  }
+
+  @Entity
+  public static class TestAnnotationBaseEntity {
+
+    @Where(clause = "SELECT 'mysql' from 1", platforms = Platform.MYSQL)
+    @Where(clause = "SELECT 'h2' from 1", platforms = Platform.H2)
+    @Where(clause = "SELECT 'other' from 1")
+    private String direct;
+
+    @MetaTest
+    private String meta;
+
+
+    @MetaTest
+    @Where(clause = "SELECT 'oracle' from 1", platforms = Platform.ORACLE)
+    private String mixed;
+
+    @Size.List({
+      @Size(max = 10, message = "max length for you is 10"),
+      @Size(min = 1),
+      @Size(max = 40, message = "max value for you is 40", groups = ValidationGroupSomething.class)
+    })
+    private String constraintAnnotation;
+
+    @NotNull
+    private String null1;
+
+
+    @NotNull(groups = ValidationGroupSomething.class)
+    private String null2;
+
+    @NotNull(groups = {ValidationGroupSomething.class, EbeanDDL.class})
+    private String null3;
+
+
+    public String getDirect() {
+      return direct;
+    }
+
+    public void setDirect(String direct) {
+      this.direct = direct;
+    }
+
+    public String getMeta() {
+      return meta;
+    }
+
+    public void setMeta(String meta) {
+      this.meta = meta;
+    }
+
+    public String getMixed() {
+      return mixed;
+    }
+
+    public void setMixed(String mixed) {
+      this.mixed = mixed;
+    }
+
+    public String getConstraintAnnotation() {
+      return constraintAnnotation;
+    }
+
+    public void setConstraintAnnotation(String constraintAnnotation) {
+      this.constraintAnnotation = constraintAnnotation;
+    }
+
+    public String getNull1() {
+      return null1;
+    }
+
+    public void setNull1(String null1) {
+      this.null1 = null1;
+    }
+
+    public String getNull2() {
+      return null2;
+    }
+
+    public void setNull2(String null2) {
+      this.null2 = null2;
+    }
+
+    public String getNull3() {
+      return null3;
+    }
+
+    public void setNull3(String null3) {
+      this.null3 = null3;
+    }
+  }
+
+
+  @Test
+  public void testFindMaxSize() throws NoSuchFieldException, SecurityException {
+    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestAnnotationBaseEntity.class);
+    BeanProperty bp = descriptor.findBeanProperty("constraintAnnotation");
+    assertEquals(40, bp.getDbLength());
+  }
+
+  @Test
+  public void testNotNullWithGroup() throws NoSuchFieldException, SecurityException {
+    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestAnnotationBaseEntity.class);
+
+    BeanProperty bp = descriptor.findBeanProperty("null1");
+    assertFalse(bp.isNullable());
+
+    bp = descriptor.findBeanProperty("null2");
+    assertTrue(bp.isNullable());
+
+    bp = descriptor.findBeanProperty("null3");
+    assertFalse(bp.isNullable());
+  }
+
+  @Test
+  public void testFindAnnotation() throws NoSuchFieldException, SecurityException {
+    Field fld = TestAnnotationBaseEntity.class.getDeclaredField("direct");
+    String s;
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.MYSQL).clause();
+    assertEquals("SELECT 'mysql' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.H2).clause();
+    assertEquals("SELECT 'h2' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.POSTGRES).clause();
+    assertEquals("SELECT 'other' from 1", s);
+
+    // meta
+    fld = TestAnnotationBaseEntity.class.getDeclaredField("meta");
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.MYSQL).clause();
+    assertEquals("SELECT 'mysql' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.H2).clause();
+    assertEquals("SELECT 'h2' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.POSTGRES).clause();
+    assertEquals("SELECT 'other' from 1", s);
+
+
+    // mixed
+    fld = TestAnnotationBaseEntity.class.getDeclaredField("mixed");
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.MYSQL).clause();
+    assertEquals("SELECT 'mysql' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.H2).clause();
+    assertEquals("SELECT 'h2' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.POSTGRES).clause();
+    assertEquals("SELECT 'other' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.ORACLE).clause();
+    assertEquals("SELECT 'oracle' from 1", s);
+  }
+
+}

src/test/java/org/tests/basic/TestAssocOneEqExpression.java

@@ -0,0 +1,43 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+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;
+
+public class TestAssocOneEqExpression extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Customer c = new Customer();
+    c.setId(1);
+
+    Query<Order> query = Ebean.find(Order.class)
+      .where().eq("customer", c)
+      .query();
+
+    query.findList();
+    String sql = query.getGeneratedSql();
+    Assert.assertTrue(sql.contains("where t0.kcustomer_id = ?"));
+
+    Address b = new Address();
+    b.setId((short) 1);
+
+    Query<Order> q2 = Ebean.find(Order.class)
+      .where().eq("customer.billingAddress", b)
+      .query();
+
+    q2.findList();
+    sql = q2.getGeneratedSql();
+    Assert.assertTrue(sql.contains("where t1.billing_address_id = ?"));
+
+  }
+}

src/test/java/org/tests/basic/TestBatchLazy.java

@@ -0,0 +1,41 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestBatchLazy extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class);
+    List<Order> list = query.findList();
+
+
+    for (Order order : list) {
+      Customer customer = order.getCustomer();
+      customer.getName();
+
+      List<OrderDetail> details = order.getDetails();
+      for (OrderDetail orderDetail : details) {
+        orderDetail.getProduct().getSku();
+      }
+    }
+
+    Ebean.getDefaultServer().getAutoTune().collectProfiling();
+    Ebean.getDefaultServer().getAutoTune().reportProfiling();
+
+  }
+
+
+}

src/test/java/org/tests/basic/TestBatchLazyMany.java

@@ -0,0 +1,35 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+public class TestBatchLazyMany extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    ResetBasicData.reset();
+
+    Order order2 = Ebean.getReference(Order.class, 1);
+    order2.getOrderDate();
+
+//		List<Order> list = Ebean.find(Order.class)
+//			//.join("details")
+//			//.join("details", "+fetchquery")
+//			.findList();
+//
+//		Order order = list.get(0);
+//		//List<OrderDetail> details = order.getDetails();
+//		//details.size();
+//
+//		Customer customer = order.getCustomer();
+//		customer.getName();
+//		System.out.println("done");
+
+  }
+
+
+}

src/test/java/org/tests/basic/TestBeanReferenceRefresh.java

@@ -0,0 +1,52 @@
+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);
+
+  }
+
+
+}

src/test/java/org/tests/basic/TestDeleteByIdCollection.java

@@ -0,0 +1,79 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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;
+
+public class TestDeleteByIdCollection extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    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);
+
+    Customer c0Back = Ebean.find(Customer.class, c0.getId());
+    Customer c1Back = Ebean.find(Customer.class, "" + c1.getId());
+
+    Assert.assertNotNull(c0Back);
+    Assert.assertNotNull(c1Back);
+
+    List<String> ids = new ArrayList<>();
+    // also test id type conversion
+    ids.add("" + c0.getId());
+    ids.add("" + c1.getId());
+
+
+    Ebean.deleteAll(Customer.class, ids);
+    awaitL2Cache();
+
+    c0Back = Ebean.find(Customer.class, c0.getId());
+    c1Back = Ebean.find(Customer.class, "" + c1.getId());
+
+    Assert.assertNull(c0Back);
+    Assert.assertNull(c1Back);
+  }
+
+  @Test
+  public void testDelByStatement() {
+
+    ResetBasicData.reset();
+
+    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());
+
+    Assert.assertNotNull(o0Back);
+    Assert.assertNotNull(o1Back);
+
+
+    List<Object> ids = new ArrayList<>();
+    // also test id type conversion
+    ids.add(order0.getId());
+    ids.add(order1.getId());
+
+    Ebean.deleteAll(Order.class, ids);
+    awaitL2Cache();
+
+    o0Back = Ebean.find(Order.class, order0.getId());
+    o1Back = Ebean.find(Order.class, order1.getId());
+
+    Assert.assertNull(o0Back);
+    Assert.assertNull(o1Back);
+  }
+
+}

src/test/java/org/tests/basic/TestDeleteCascadingOneToMany.java

@@ -0,0 +1,20 @@
+package org.tests.basic;
+
+import io.ebean.Ebean;
+import org.tests.model.basic.Article;
+import org.tests.model.basic.Section;
+import junit.framework.TestCase;
+
+public class TestDeleteCascadingOneToMany extends TestCase {
+
+  public void testDeleteCascadingOneToMany() {
+    Section s0 = new Section("some content");
+    Article a0 = new Article("art1", "auth1");
+    a0.addSection(s0);
+
+    Ebean.save(a0);
+
+    Ebean.delete(a0);
+  }
+
+}

src/test/java/org/tests/basic/TestDeleteImportedPartial.java

@@ -0,0 +1,34 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PFile;
+import org.tests.model.basic.PFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeleteImportedPartial extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    PFile persistentFile = new PFile("test.txt", new PFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+    Integer id = persistentFile.getId();
+    Integer contentId = persistentFile.getFileContent().getId();
+
+    PFile partialPfile = Ebean.find(PFile.class).select("id").where().idEq(persistentFile.getId())
+      .findUnique();
+
+    // should delete file and fileContent
+    Ebean.delete(partialPfile);
+
+    PFile file1 = Ebean.find(PFile.class, id);
+    PFileContent content1 = Ebean.find(PFileContent.class, contentId);
+
+    Assert.assertNull(file1);
+    Assert.assertNull(content1);
+
+  }
+}

src/test/java/org/tests/basic/TestDeleteOneToOne.java

@@ -0,0 +1,50 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PersistentFile;
+import org.tests.model.basic.PersistentFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeleteOneToOne extends BaseTestCase {
+
+  @Test
+  public void testCreateDeletePersistentFile() {
+
+    PersistentFile persistentFile = new PersistentFile("test.txt", new PersistentFileContent(
+      "test".getBytes()));
+
+    Ebean.save(persistentFile);
+    Integer id = persistentFile.getId();
+    Integer contentId = persistentFile.getPersistentFileContent().getId();
+
+    // should delete file and fileContent
+    Ebean.delete(PersistentFile.class, id);
+
+    PersistentFile file1 = Ebean.find(PersistentFile.class, id);
+    PersistentFileContent content1 = Ebean.find(PersistentFileContent.class, contentId);
+
+    Assert.assertNull(file1);
+    Assert.assertNull(content1);
+
+  }
+
+  // public void testDeleteMany() {
+  //
+  // Customer c = new Customer();
+  // c.setName("Fiona");
+  // c.setStatus(Customer.Status.ACTIVE);
+  // c.addContact(new Contact("Fiona", "Black"));
+  // c.addContact(new Contact("Tracy", "Red"));
+  //
+  // Ebean.save(c);
+  //
+  // Ebean.delete(Customer.class, c.getId());
+  //
+  // Customer deletedCustomer = Ebean.find(Customer.class, c.getId());
+  //
+  // Assert.assertNull(deletedCustomer);
+  //
+  // }
+}

src/test/java/org/tests/basic/TestDeleteOneToOneMultiple.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PFile;
+import org.tests.model.basic.PFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeleteOneToOneMultiple extends BaseTestCase {
+
+  @Test
+  public void testCreateDeletePersistentFile() {
+
+    PFile persistentFile = new PFile("test.txt", new PFileContent("test".getBytes()));
+//    PFile persistentFile = new PFile();
+//    persistentFile.setName("test.txt");
+//    PFileContent content = new PFileContent();
+//    content.setContent("test".getBytes());
+//    persistentFile.setFileContent(content);
+
+    Ebean.save(persistentFile);
+    Integer id = persistentFile.getId();
+    Integer contentId = persistentFile.getFileContent().getId();
+
+    // should delete file and fileContent
+    Ebean.delete(PFile.class, id);
+
+    PFile file1 = Ebean.find(PFile.class, id);
+    PFileContent content1 = Ebean.find(PFileContent.class, contentId);
+
+    Assert.assertNull(file1);
+    Assert.assertNull(content1);
+
+  }
+
+}

src/test/java/org/tests/basic/TestDeletePartialNoVersion.java

@@ -0,0 +1,54 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TMapSuperEntity;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeletePartialNoVersion extends BaseTestCase {
+
+  @Test
+  public void testNoVersion() {
+
+    TMapSuperEntity e = new TMapSuperEntity();
+    e.setName("babanaone");
+
+    Ebean.save(e);
+
+    // select includes a transient property
+    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+      .where().idEq(e.getId())
+      .select("id, name")
+      .findUnique();
+
+    Assert.assertNotNull(e2);
+
+    e2.setName("banaban2");
+    Ebean.save(e2);
+
+    Ebean.delete(e2);
+  }
+
+
+  public void testWithVersion() {
+
+    TMapSuperEntity e = new TMapSuperEntity();
+    e.setName("babanatwo");
+
+    Ebean.save(e);
+
+    // select includes a transient property
+    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+      .where().idEq(e.getId())
+      .select("id, name, version")
+      .findUnique();
+
+    Assert.assertNotNull(e2);
+
+    e2.setName("banaban2two");
+    Ebean.save(e2);
+
+    Ebean.delete(e2);
+  }
+}

src/test/java/org/tests/basic/TestDynamicUpdate.java

@@ -0,0 +1,53 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import org.tests.model.embedded.EMain;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDynamicUpdate extends BaseTestCase {
+
+  @Test
+  public void testUpdate() {
+
+    // insert
+    EMain b = new EMain();
+    b.setName("aaa");
+    b.getEmbeddable().setDescription("123");
+
+    EbeanServer server = Ebean.getServer(null);
+
+    server.save(b);
+
+    Assert.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);
+    boolean dirty = beanState.isDirty();
+    Assert.assertTrue(dirty);
+
+    server.save(b2);
+
+    server.beginTransaction();
+    try {
+      EMain b3 = server.find(EMain.class, b.getId());
+      Assert.assertEquals("ABC", b3.getEmbeddable().getDescription());
+    } finally {
+      server.endTransaction();
+    }
+    EMain b4 = server.find(EMain.class, b.getId());
+    b4.setName("bbb");
+    b4.getEmbeddable().setDescription("123");
+    server.save(b4);
+
+    EMain b5 = server.find(EMain.class, b.getId());
+    Assert.assertEquals("123", b5.getEmbeddable().getDescription());
+  }
+}

src/test/java/org/tests/basic/TestEnhancementCollectionInitialisation.java

@@ -0,0 +1,28 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+
+public class TestEnhancementCollectionInitialisation extends BaseTestCase {
+
+  @Test
+  public void testListInitialisation() {
+
+    Customer customer = new Customer();
+    BeanState beanState = Ebean.getBeanState(customer);
+    if (beanState != null) {
+      List<Order> orders = customer.getOrders();
+      Assert.assertNotNull(orders);
+    }
+
+  }
+
+}

src/test/java/org/tests/basic/TestErrorBindLog.java

@@ -0,0 +1,24 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.junit.Assert;
+import org.junit.Test;
+
+import javax.persistence.PersistenceException;
+
+public class TestErrorBindLog extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    try {
+      Ebean.find(Order.class).where().gt("id", "JUNK").findList();
+
+    } catch (PersistenceException e) {
+      String msg = e.getMessage();
+      Assert.assertTrue(msg.contains("Bind values:"));
+    }
+  }
+}

src/test/java/org/tests/basic/TestExplicitInsert.java

@@ -0,0 +1,90 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+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;
+
+public class TestExplicitInsert extends BaseTestCase {
+
+  @Test
+  public void setId_when_converted() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+
+    Customer cust = new Customer();
+    Object returnId = server.setBeanId(cust, "42");
+
+    assertThat(returnId).isEqualTo(42);
+    assertThat(cust.getId()).isEqualTo(42);
+  }
+
+  @Test
+  public void setId_when_correctType() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+
+    Customer customer = new Customer();
+    Object returnId = server.setBeanId(customer, 42);
+
+    assertThat(returnId).isEqualTo(42);
+    assertThat(customer.getId()).isEqualTo(42);
+  }
+
+  @Test
+  public void test() throws InterruptedException {
+
+    Thread.sleep(100);
+
+    MyEBasicConfigStartup.resetCounters();
+
+    EBasic b = new EBasic();
+    b.setName("exp insert");
+    b.setDescription("explicit insert");
+    b.setStatus(EBasic.Status.ACTIVE);
+
+    EbeanServer server = Ebean.getDefaultServer();
+    server.insert(b);
+
+    Assert.assertNotNull(b.getId());
+
+    Assert.assertEquals(b.getId(), server.getBeanId(b));
+
+
+    EBasic b2 = server.find(EBasic.class, b.getId());
+    b2.setId(null);
+
+    b2.setName("force insert");
+    server.insert(b2);
+
+    Assert.assertNotNull(b2.getId());
+    Assert.assertTrue(!b.getId().equals(b2.getId()));
+
+    List<EBasic> list = server.find(EBasic.class).where().in("id", b.getId(), b2.getId()).findList();
+
+    assertEquals(2, list.size());
+
+    b2.setName("do an update");
+    server.save(b2);
+
+    server.delete(b);
+    server.delete(b2);
+
+    // just sleep a little to allow the background thread to fire
+    Thread.sleep(100);
+
+    assertEquals(2, MyEBasicConfigStartup.insertCount.get());
+    assertEquals(1, MyEBasicConfigStartup.updateCount.get());
+    assertEquals(2, MyEBasicConfigStartup.deleteCount.get());
+  }
+
+}

src/test/java/org/tests/basic/TestFetchId.java

@@ -0,0 +1,39 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.FutureIds;
+import io.ebean.Query;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestFetchId extends BaseTestCase {
+
+  @Test
+  public void testFetchId() throws InterruptedException, ExecutionException {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("id", 1)
+      .gt("details.id", 0)
+      .query();
+
+    List<Object> ids = Ebean.getServer(null).findIds(query, null);
+    assertThat(ids).isNotEmpty();
+
+    FutureIds<Order> futureIds = Ebean.getServer(null).findFutureIds(query, null);
+
+    // wait for all the id's to be fetched
+    List<Object> idList = futureIds.get();
+    assertThat(idList).isNotEmpty();
+  }
+}

src/test/java/org/tests/basic/TestIUDVanilla.java

@@ -0,0 +1,51 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.EBasicVer;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+
+public class TestIUDVanilla extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasicVer e0 = new EBasicVer("vanilla");
+
+    Ebean.save(e0);
+
+    Assert.assertNotNull(e0.getId());
+    Assert.assertNotNull(e0.getLastUpdate());
+
+    Timestamp lastUpdate0 = e0.getLastUpdate();
+
+    e0.setName("modified");
+    Ebean.save(e0);
+
+    Timestamp lastUpdate1 = e0.getLastUpdate();
+    Assert.assertNotNull(lastUpdate1);
+    Assert.assertNotSame(lastUpdate0, lastUpdate1);
+
+    EBasicVer e2 = Ebean.getServer(null).createEntityBean(EBasicVer.class);
+
+    e2.setId(e0.getId());
+    e2.setLastUpdate(lastUpdate1);
+
+    e2.setName("forcedUpdate");
+    Ebean.update(e2);
+
+    EBasicVer e3 = new EBasicVer("ModNoOCC");
+    e3.setId(e0.getId());
+
+    Ebean.update(e3);
+
+    e3.setName("ModAgain");
+    e3.setDescription("Banana");
+
+    Ebean.update(e3);
+
+  }
+}

src/test/java/org/tests/basic/TestInEmpty.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+import static org.junit.Assert.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();
+
+    List<Order> list = query.findList();
+    assertThat(query.getGeneratedSql()).contains("1=0");
+    assertEquals(0, list.size());
+  }
+
+  @Test
+  public void test_notIn_empty() {
+
+    Query<Order> query = Ebean.find(Order.class).where().notIn("id", new Object[0]).gt("id", 0)
+      .query();
+
+    query.findList();
+    assertThat(query.getGeneratedSql()).contains("1=1");
+  }
+
+}

src/test/java/org/tests/basic/TestInheritRef.java

@@ -0,0 +1,58 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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;
+
+public class TestInheritRef extends BaseTestCase {
+
+  @Test
+  public void testAssocOne() {
+
+    Ebean.beginTransaction();
+    try {
+      Ebean.createUpdate(Vehicle.class, "delete from vehicle");
+
+      Car c = new Car();
+      c.setLicenseNumber("C6788");
+      c.setDriver("CarDriver");
+      Ebean.save(c);
+
+      Truck t = new Truck();
+      t.setLicenseNumber("T1098BBX");
+      t.setCapacity(20D);
+      Ebean.save(t);
+
+      List<Vehicle> list = Ebean.find(Vehicle.class)
+        .setAutoTune(false)
+        .findList();
+
+      Assert.assertTrue(!list.isEmpty());
+
+      Truck foundTruck = null;
+      int found = 0;
+
+      for (Vehicle vehicle : list) {
+        if (vehicle instanceof Truck) {
+          Truck truck = (Truck) vehicle;
+          if ("T1098BBX".equals(truck.getLicenseNumber())) {
+            found++;
+            foundTruck = truck;
+          }
+        }
+      }
+
+      Assert.assertEquals(1, found);
+      Assert.assertTrue(foundTruck.getCapacity() == 20D);
+
+    } finally {
+      Ebean.rollbackTransaction();
+    }
+  }
+}

src/test/java/org/tests/basic/TestJodaType.java

@@ -0,0 +1,43 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanProperty;
+import io.ebeaninternal.server.type.ScalarType;
+import org.tests.model.basic.TJodaEntity;
+import org.joda.time.LocalTime;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+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();
+
+    Assert.assertNotNull(scalarType);
+  }
+
+  @Test
+  public void test_insert_find() {
+
+    LocalTime now = new LocalTime().withMillisOfSecond(0);
+
+    TJodaEntity bean = new TJodaEntity();
+    bean.setLocalTime(now);
+    Ebean.save(bean);
+
+    TJodaEntity foundBean = Ebean.find(TJodaEntity.class, bean.getId());
+
+    assertThat(foundBean.getLocalTime()).isEqualTo(bean.getLocalTime());
+  }
+
+}

src/test/java/org/tests/basic/TestJoinInheritance.java

@@ -0,0 +1,80 @@
+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 java.sql.Timestamp;
+import java.util.Date;
+
+public class TestJoinInheritance extends BaseTestCase {
+
+
+  /**
+   * Test join hierarchy assoc one.
+   * <p>
+   * This test catches the problem where the discriminator column is select
+   * but is not skipped if the parent bean is already in the presistence context.
+   * <p>
+   * Test case: We have several trips with different addresses but always the same
+   * driver and car (the cars could be different). So the driver will be loaded
+   * when the first trip is loaded but when the second trip is loaded the driver is
+   * found in the persistence context. So the bean is not read but the index in the
+   * result set is forwarded by the number of properties - however, the vehicle type
+   * column was not being skipped - but the query reads happily - only the data is
+   * then wrong in the address object.
+   */
+  @Test
+  public void testJoinHierarchyAssocOne() {
+
+    Ebean.createUpdate(Vehicle.class, "delete from vehicle");
+
+
+    Address address = new Address();
+    address.setLine1("Street");
+    address.setLine2("Street");
+    address.setCity("City");
+
+    address.setCretime(new Timestamp(new Date().getTime()));
+
+    Ebean.save(address);
+
+    Car c = new Car();
+    c.setLicenseNumber("C6788");
+    c.setDriver("CarDriver");
+    c.setRegistrationDate(new Date());
+    Ebean.save(c);
+
+    VehicleDriver driver = new VehicleDriver();
+
+    driver.setVehicle(c);
+    driver.setAddress(address);
+    driver.setLicenseIssuedOn(new Date());
+    Ebean.save(driver);
+
+    final String line1 = "Street1";
+    final String line2 = "Street2";
+    final String city = "City";
+
+    int nrDrivers = 2;
+    for (int i = 0; i < nrDrivers; i++) {
+      Address address1 = new Address();
+      address1.setLine1(line1);
+      address1.setLine2(line2);
+      address1.setCity(city);
+      Ebean.save(address1);
+
+      Trip trip = new Trip();
+      trip.setVehicleDriver(driver);
+      trip.setAddress(address1);
+      trip.setCretime(new Timestamp(new Date().getTime()));
+      Ebean.save(trip);
+    }
+
+  }
+}

src/test/java/org/tests/basic/TestLazyLoadEmptyOneToMany.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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;
+
+public class TestLazyLoadEmptyOneToMany extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Customer c = new Customer();
+    c.setName("testll");
+
+    Ebean.save(c);
+
+    Customer c1 = Ebean.find(Customer.class)
+      .setAutoTune(false)
+      .select("id")
+      .fetch("contacts", "id")
+      .where().idEq(c.getId())
+      .findUnique();
+
+    List<Contact> contacts = c1.getContacts();
+    int sz = contacts.size();
+
+    Assert.assertTrue(sz == 0);
+  }
+}

src/test/java/org/tests/basic/TestLazyLoadInCache.java

@@ -0,0 +1,63 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class TestLazyLoadInCache extends BaseTestCase {
+
+  @Test
+  public void testLoadInCache() {
+
+    ResetBasicData.reset();
+
+    Map<Integer, Customer> map = Ebean.find(Customer.class)
+      .select("id, name")
+      .setLoadBeanCache(true)
+      .setReadOnly(true)
+      .orderBy().asc("id")
+      .findMap();
+
+    assertTrue(!map.isEmpty());
+
+    Object id = map.keySet().iterator().next();
+
+    Customer cust1 = map.get(id);
+
+    Customer cust1B = Ebean.find(Customer.class)
+      .setReadOnly(true)
+      .setId(id)
+      .findUnique();
+
+    assertTrue(cust1 != cust1B);
+
+    Set<String> loadedProps = Ebean.getBeanState(cust1).getLoadedProps();
+
+    assertTrue(loadedProps.contains("name"));
+    assertFalse(loadedProps.contains("status"));
+
+    cust1.getStatus();
+
+    // a readOnly reference
+    Address billingAddress = cust1.getBillingAddress();
+    BeanState billAddrState = Ebean.getBeanState(billingAddress);
+    assertTrue(billAddrState.isReference());
+    assertTrue(billAddrState.isReadOnly());
+
+    // lazy load .. no longer a reference
+    billingAddress.getCity();
+    assertFalse(billAddrState.isReference());
+
+  }
+
+}

src/test/java/org/tests/basic/TestLimitQuery.java

@@ -0,0 +1,139 @@
+package org.tests.basic;
+
+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;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class TestLimitQuery extends BaseTestCase {
+
+  @Test
+  public void testLimitWithMany() {
+    rob();
+    rob();
+  }
+
+  @Test
+  public void testMaxRowsZeroWithFirstRow() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .setMaxRows(0)
+      .setFirstRow(3)
+      .order().asc("orderDate");
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    if (isH2()) {
+      assertThat(sql).contains("offset 3");
+      assertThat(sql).contains("limit 0");
+    }
+  }
+
+  @Test
+  public void testMaxRowsWithFirstRowZero() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .setMaxRows(3)
+      .setFirstRow(0);
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    boolean hasLimit = sql.contains("limit 3");
+    boolean hasOffset = sql.contains("offset");
+
+    if (isH2()) {
+      Assert.assertTrue(sql, hasLimit);
+      Assert.assertFalse(sql, hasOffset);
+    }
+  }
+
+  @Test
+  public void testDefaults() {
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .query();
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    boolean hasLimit = sql.contains("limit");
+    boolean hasOffset = sql.contains("offset");
+
+    if (isH2()) {
+      Assert.assertFalse(hasLimit);
+      Assert.assertFalse(hasOffset);
+    }
+  }
+
+  private void rob() {
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .setMaxRows(10);
+    //.findList();
+
+    List<Order> list = query.findList();
+
+    Assert.assertTrue("sz > 0", !list.isEmpty());
+
+    String sql = query.getGeneratedSql();
+    boolean hasDetailsJoin = sql.contains("join o_order_detail");
+    boolean hasLimit = sql.contains("limit 10");
+    boolean hasSelectedDetails = sql.contains("od.id,");
+    boolean hasDistinct = sql.contains("select distinct");
+
+    Assert.assertTrue(hasDetailsJoin);
+    Assert.assertFalse(hasSelectedDetails);
+    Assert.assertTrue(hasDistinct);
+    if (isH2()) {
+      Assert.assertTrue(hasLimit);
+    }
+
+    query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .setMaxRows(10);
+
+    query.findList();
+
+    sql = query.getGeneratedSql();
+    hasDetailsJoin = sql.contains("left join o_order_detail");
+    hasLimit = sql.contains("limit 10");
+    hasSelectedDetails = sql.contains("od.id");
+    hasDistinct = sql.contains("select distinct");
+
+    Assert.assertFalse("no join with maxRows", hasDetailsJoin);
+    Assert.assertFalse(hasSelectedDetails);
+    Assert.assertFalse(hasDistinct);
+    if (isH2()) {
+      Assert.assertTrue(hasLimit);
+    }
+  }
+}

src/test/java/org/tests/basic/TestLoadBeanCache.java

@@ -0,0 +1,33 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Country;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Map;
+
+public class TestLoadBeanCache extends BaseTestCase {
+
+  @Test
+  public void testLoad() {
+
+    ResetBasicData.reset();
+
+    Map<String, Country> map = Ebean.find(Country.class)
+      .setLoadBeanCache(true)
+      .setUseQueryCache(true)
+      .setReadOnly(true)
+      .order("name")
+      .findMap();
+
+    Country loadedNz = map.get("NZ");
+
+    // this will hit the cache
+    Country nz = Ebean.find(Country.class, "NZ");
+
+    Assert.assertTrue(loadedNz == nz);
+  }
+}

src/test/java/org/tests/basic/TestLogTransLogOnError.java

@@ -0,0 +1,78 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.EBasicVer;
+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 TestLogTransLogOnError extends BaseTestCase {
+
+  @Test
+  public void testQueryError() {
+
+    ResetBasicData.reset();
+
+    Ebean.beginTransaction();
+    try {
+
+      Ebean.find(Customer.class).findList();
+      Ebean.find(Order.class).where().gt("id", 1).findList();
+
+      EBasicVer newBean = new EBasicVer("aName");
+      newBean.setDescription("something");
+
+      // Ebean.save(newBean);
+
+      // t.log("--- next query should error");
+      List<Customer> list = Ebean.find(Customer.class).where().eq("id", "NotAnInt!!").findList();
+
+      Assert.assertEquals(0, list.size());
+      // Get here with mysql?
+      // Assert.assertTrue(false);
+
+    } catch (RuntimeException e) {
+      // e.printStackTrace();
+      Assert.assertTrue(true);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+  }
+
+  public void testPersistError() {
+
+    ResetBasicData.reset();
+
+    Ebean.beginTransaction();
+    try {
+      Ebean.find(Customer.class).findList();
+
+      EBasicVer newBean = new EBasicVer("aName");
+      newBean
+        .setDescription("something sdfjksdjflsjdflsjdflksjdfkjd fsjdfkjsdkfjsdkfjskdjfskjdf"
+          + " sjdf sdjflksjdfkjsdlfkjsdkfjs ksjdfksjdlfjsldf something sdfjksdjflsjdflsjdflksjdfkjd"
+          + "fsjdfkjsdkfjsdkfjskdjfskjdf sjdf sdjflksjdfkjsdlfkjsdkfjs ksjdfksjdlfjsldf something s"
+          + "dfjksdjflsjdflsjdflksjdfkjd fsjdfkjsdkfjsdkfjskdjfskjdf sjdf sdjflksjdfkjsdlfkjsdkfjs ");
+
+      // t.log("--- next insert should error");
+      Ebean.save(newBean);
+
+      // never get here
+      Assert.assertTrue(false);
+
+    } catch (RuntimeException e) {
+      // e.printStackTrace();
+      Assert.assertTrue(true);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+
+  }
+}

src/test/java/org/tests/basic/TestM2MCascadeOne.java

@@ -0,0 +1,48 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.MRole;
+import org.tests.model.basic.MUser;
+import org.junit.Test;
+
+public class TestM2MCascadeOne extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    MUser u = new MUser();
+    u.setUserName("testM2M");
+
+    u.getRoles();
+    Ebean.save(u);
+
+    MRole r0 = new MRole();
+    r0.setRoleName("rol_0");
+    Ebean.save(r0);
+
+    MRole r1 = new MRole();
+    r1.setRoleName("rol_1");
+
+    MUser u1 = Ebean.find(MUser.class, u.getUserid());
+
+    u1.addRole(r0);
+    u1.addRole(r1);
+
+    Ebean.save(u1);
+
+  }
+
+  @Test
+  public void testRawPredicate_with_ManyToManyPath() {
+
+    Query<MUser> query = Ebean.find(MUser.class)
+      .select("userid")
+      .where().raw("roles.roleid in (?)", 24)
+      .query();
+
+    query.findList();
+
+  }
+}

src/test/java/org/tests/basic/TestM2MVanilla.java

@@ -0,0 +1,102 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebean.SqlUpdate;
+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.List;
+
+public class TestM2MVanilla extends BaseTestCase {
+
+  @Test
+  public void testVanilla() {
+
+    SqlUpdate delInt = Ebean.createSqlUpdate("delete from mrole_muser");
+    SqlUpdate delRoles = Ebean.createSqlUpdate("delete from mrole");
+    SqlUpdate delUsers = Ebean.createSqlUpdate("delete from muser");
+
+    Ebean.execute(delInt);
+    Ebean.execute(delRoles);
+    Ebean.execute(delUsers);
+
+    MRole r1 = new MRole();
+    r1.setRoleName("role1");
+    Ebean.save(r1);
+
+    MRole r2 = new MRole();
+    r2.setRoleName("role2");
+    Ebean.save(r2);
+
+    MRole r3 = new MRole();
+    r3.setRoleName("role3");
+    Ebean.save(r3);
+
+    MUser u0 = new MUser();
+    u0.setUserName("something");
+
+    Ebean.save(u0);
+
+    MUser user = Ebean.find(MUser.class, u0.getUserid());
+
+    List<MRole> roleList = new ArrayList<>();
+    roleList.add(r1);
+    roleList.add(r2);
+
+    user.setRoles(roleList);
+
+    Ebean.save(user);
+    // Ebean.saveManyToManyAssociations(user, "roles");
+
+    MUser checkUser = Ebean.find(MUser.class, u0.getUserid());
+    List<MRole> checkRoles = checkUser.getRoles();
+    Assert.assertNotNull(checkRoles);
+    Assert.assertEquals(2, checkRoles.size());
+
+    checkRoles.add(r3);
+
+    Ebean.save(checkUser);
+    // Ebean.saveManyToManyAssociations(checkUser, "roles");
+
+    MUser checkUser2 = Ebean.find(MUser.class, u0.getUserid());
+    List<MRole> checkRoles2 = checkUser2.getRoles();
+    Assert.assertNotNull(checkRoles2);
+    Assert.assertEquals("added a role", 3, checkRoles2.size());
+
+    Query<MUser> rolesQuery0 = Ebean.find(MUser.class).where().eq("roles", r1).query();
+
+    rolesQuery0.findList();
+
+    Query<MUser> rolesQuery = Ebean.find(MUser.class).where().in("roles", roleList).query();
+
+    List<MUser> userInRolesList = rolesQuery.findList();
+    Assert.assertTrue(!userInRolesList.isEmpty());
+
+    List<MUser> list = Ebean.find(MUser.class)
+      .where().in("roles", roleList)
+      .filterMany("roles").eq("roleName", "role1")
+      .findList();
+
+    MUser mUser = list.get(0);
+    List<MRole> roles = mUser.getRoles();
+    Assert.assertEquals(1, roles.size());
+
+    checkRoles2.remove(0);
+    checkRoles2.remove(0);
+    Ebean.save(checkUser2);
+
+    checkUser2 = Ebean.find(MUser.class, u0.getUserid());
+    checkRoles2 = checkUser2.getRoles();
+    Assert.assertNotNull(checkRoles2);
+    Assert.assertEquals("added a role", 1, checkRoles2.size());
+
+    Ebean.delete(checkUser2);
+
+  }
+
+}

src/test/java/org/tests/basic/TestManyLazyLoad.java

@@ -0,0 +1,64 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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.*;
+
+public class TestManyLazyLoad extends BaseTestCase {
+
+  @Test
+  public void testLazyLoadRef() throws InterruptedException {
+
+    ResetBasicData.reset();
+
+    awaitL2Cache();
+
+    List<Order> list = Ebean.find(Order.class).order().asc("id").findList();
+    assertTrue(list.size() + " > 0", !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());
+    assertNotNull(order1);
+
+    Date orderDate = order1.getOrderDate();
+    assertNotNull(orderDate);
+
+    List<OrderDetail> details = order1.getDetails();
+
+    // lazy load the details
+    int sz = details.size();
+    assertTrue(sz + " > 0", sz > 0);
+
+    OrderDetail orderDetail = details.get(0);
+    Order o = orderDetail.getOrder();
+    assertSame(o, order1);
+
+    // load detail into cache
+    Ebean.find(OrderDetail.class, orderDetail.getId());
+
+    // change order... list before a scalar property
+    Order order2 = Ebean.getReference(Order.class, order.getId());
+    assertNotNull(order2);
+
+    List<OrderDetail> details2 = order2.getDetails();
+
+    // lazy load the details
+    int sz2 = details2.size();
+    assertTrue(sz2 + " > 0", sz2 > 0);
+
+    Order o2 = details2.get(0).getOrder();
+    assertSame(o2, order2);
+  }
+
+}

src/test/java/org/tests/basic/TestManyOneInterface.java

@@ -0,0 +1,31 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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 {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    IAddress a = new Address();
+
+    IPerson p = new Person();
+
+    p.setDefaultAddress(a);
+
+    Ebean.save(a);
+    Ebean.save(p);
+
+    //Assert.assertTrue();
+
+  }
+}

src/test/java/org/tests/basic/TestMappedSuper.java

@@ -0,0 +1,35 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TMapSuperEntity;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestMappedSuper extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TMapSuperEntity e = new TMapSuperEntity();
+    e.setName("babana");
+
+    Ebean.save(e);
+
+    // select includes a transient property
+    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+      .where().idEq(e.getId())
+      .select("id, name, myint, someObject, bananan")
+      .findUnique();
+
+    Assert.assertNotNull(e2);
+
+    TMapSuperEntity eSaveDelete = new TMapSuperEntity();
+    eSaveDelete.setName("babana");
+
+    Ebean.save(eSaveDelete);
+
+    Ebean.delete(eSaveDelete);
+  }
+
+}

src/test/java/org/tests/basic/TestMetaAnnotation.java

@@ -0,0 +1,81 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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;
+
+/**
+ * Very simple test case to check if Ebean recognizes meta-annotation correctly.
+ *
+ * @author Roland Praml, FOCONIS AG
+ */
+public class TestMetaAnnotation extends BaseTestCase {
+
+  private static final String spaces100 = new String(new char[100]).replace('\0', ' ');
+  private static final String spaces101 = new String(new char[101]).replace('\0', ' ');
+
+  /**
+   * This test writes 100 spaces to "line1" which is annotated with @Size(max=100)
+   */
+  @Test
+  public void testWrite100SpacesToLine1() {
+
+    Address address = new Address();
+    address.setLine1(spaces100);
+    Ebean.save(address);
+  }
+
+  /**
+   * This test writes 100 spaces to "line1" which is meta-annotated with {@link SizeMedium}.
+   */
+  @Test
+  public void testWrite100SpacesToLine2() {
+
+    Address address = new Address();
+    address.setLine2(spaces100);
+    Ebean.save(address);
+  }
+
+  /**
+   * This test writes 101 spaces to "line1" which is annotated with @Size(max=100).
+   */
+  @Test
+  public void testWrite101SpacesToLine1() {
+
+    if (isH2()) {
+      Address address = new Address();
+      address.setLine1(spaces101);
+      try {
+        Ebean.save(address);
+        assertTrue("H2 fails this insert", false);
+      } catch (PersistenceException e) {
+        assertTrue(true);
+      }
+    }
+  }
+
+  /**
+   * This test writes 101 spaces to "line1" which is meta-annotated with {@link SizeMedium}.
+   */
+  @Test
+  public void testWrite101SpacesToLine2() {
+
+    if (isH2()) {
+      Address address = new Address();
+      address.setLine2(spaces101);
+      try {
+        Ebean.save(address);
+        assertTrue("H2 fails this insert", false);
+      } catch (PersistenceException e) {
+        assertTrue(true);
+      }
+    }
+  }
+
+}

src/test/java/org/tests/basic/TestMultipleOneToOneIUD.java

@@ -0,0 +1,60 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.OCar;
+import org.tests.model.basic.OEngine;
+import org.tests.model.basic.OGearBox;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestMultipleOneToOneIUD extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    OEngine engine = new OEngine();
+    engine.setShortDesc("engine 1");
+
+    OGearBox gearBox = new OGearBox();
+    gearBox.setBoxDesc("6 speed manual");
+    gearBox.setSize(6);
+
+    OCar car = new OCar();
+    car.setVin("xx4534");
+    car.setName("test car");
+    car.setEngine(engine);
+
+    Ebean.beginTransaction();
+    try {
+      Ebean.save(gearBox);
+      Ebean.save(car);
+
+      Assert.assertNotNull(car.getId());
+      Assert.assertNotNull(engine.getEngineId());
+      Assert.assertNotNull(gearBox.getId());
+
+      Ebean.commitTransaction();
+
+    } finally {
+      Ebean.endTransaction();
+    }
+
+    OCar c2 = Ebean.find(OCar.class, car.getId());
+    Assert.assertNotNull(c2);
+    Assert.assertNotNull(c2.getEngine());
+    // gearBox not assigned yet
+    Assert.assertNull(c2.getGearBox());
+
+    // ok, assign gearBox
+    c2.setGearBox(gearBox);
+    Ebean.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());
+
+  }
+}

src/test/java/org/tests/basic/TestNonUpdateProperty.java

@@ -0,0 +1,25 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.MNonUpdPropEntity;
+import org.junit.Test;
+
+public class TestNonUpdateProperty extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    MNonUpdPropEntity e = new MNonUpdPropEntity();
+    e.setName("name");
+    e.setNote("note");
+
+    Ebean.save(e);
+
+    MNonUpdPropEntity e2 = Ebean.find(MNonUpdPropEntity.class, e.getId());
+
+    e2.setName("mod");
+    Ebean.update(e2);
+
+  }
+}

src/test/java/org/tests/basic/TestOrderByAnnotation.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+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 TestOrderByAnnotation extends BaseTestCase {
+
+  @Test
+  public void testOrderBy() {
+
+    ResetBasicData.reset();
+    Customer custTest = ResetBasicData.createCustAndOrder("testOrderByAnn");
+
+    Customer customer = Ebean.find(Customer.class, custTest.getId());
+    List<Order> orders = customer.getOrders();
+
+    Assert.assertTrue(!orders.isEmpty());
+
+
+    Query<Order> q1 = Ebean.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"));
+  }
+}

src/test/java/org/tests/basic/TestOrderTotalAmountFormula.java

@@ -0,0 +1,38 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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;
+
+public class TestOrderTotalAmountFormula extends BaseTestCase {
+
+  @Test
+  public void testAsJoin() {
+
+    ResetBasicData.reset();
+
+    List<Customer> l0 = Ebean.find(Customer.class)
+      .select("id, name")
+      .fetch("orders", "status, totalAmount")
+      .where()
+      .eq("orders.details.product.name", "Desk")
+      .like("contacts.firstName", "Ji%")
+      .findList();
+
+    for (Customer c0 : l0) {
+      c0.getId();
+      List<Order> orders = c0.getOrders();
+      for (Order order : orders) {
+        order.getId();
+      }
+    }
+
+  }
+
+
+}

src/test/java/org/tests/basic/TestOrderTotalAmountReportBean.java

@@ -0,0 +1,153 @@
+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.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.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertNotNull;
+
+public class TestOrderTotalAmountReportBean extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    String sql =
+      "select order_id, count(*) as totalItems, sum(order_qty*unit_price) as totalAmount \n" +
+        "from o_order_detail \n" +
+        "group by order_id";
+
+    RawSql rawSql = RawSqlBuilder.parse(sql).columnMapping("order_id", "order.id").create();
+
+    List<OrderAggregate> l0 =
+      Ebean.find(OrderAggregate.class)
+        .setRawSql(rawSql)
+        .findList();
+
+    for (OrderAggregate r0 : l0) {
+      r0.toString();
+    }
+
+    List<OrderAggregate> l2 = Ebean.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);
+    }
+
+  }
+
+  @Test
+  public void test_when_aliasInUnderscore() {
+
+    ResetBasicData.reset();
+
+    String sql =
+      "select order_id, count(*) as total_items, sum(order_qty*unit_price) as total_amount \n" +
+        "from o_order_detail \n" +
+        "group by order_id";
+
+    RawSql rawSql = RawSqlBuilder.parse(sql)
+      .columnMapping("order_id", "order.id")
+      .create();
+
+    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class)
+      .setRawSql(rawSql);
+
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount");
+  }
+
+  @Test
+  public void test_when_aliasInCamelCase() {
+
+    ResetBasicData.reset();
+
+    String sql =
+      "select order_id, count(*) as totalItems, sum(order_qty*unit_price) as totalAmount \n" +
+        "from o_order_detail \n" +
+        "group by order_id";
+
+    RawSql rawSql = RawSqlBuilder.parse(sql)
+      .columnMapping("order_id", "order.id")
+      .create();
+
+    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class)
+      .setRawSql(rawSql);
+
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as totalItems, sum(order_qty*unit_price) as totalAmount");
+  }
+
+  @Test
+  public void testDefaultNamedRawSql() {
+
+    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class);
+    List<OrderAggregate> list = query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount");
+    assertNotNull(list);
+  }
+
+  @Test
+  public void testNamedRawSql() {
+
+    ResetBasicData.reset();
+
+    Query<OrderAggregate> query = Ebean.getDefaultServer().createNamedQuery(OrderAggregate.class, "withMax");
+    List<OrderAggregate> list = query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount, max(order_qty*unit_price) as maxAmount from o_order_detail");
+    assertNotNull(list);
+  }
+
+  @Test
+  public void testNamedRawSql_with_extraPredicates() {
+
+    ResetBasicData.reset();
+
+    Query<OrderAggregate> query = Ebean.getDefaultServer().createNamedQuery(OrderAggregate.class, "withMax");
+    List<OrderAggregate> list = query
+      .where().gt("order.id", 1)
+      .having().gt("totalItems", 1)
+      .order().desc("totalAmount")
+      .findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount, max(order_qty*unit_price) as maxAmount from o_order_detail");
+    assertThat(query.getGeneratedSql()).contains("from o_order_detail  where order_id > ?  group by order_id  having count(*) > ?   order by sum(order_qty*unit_price) desc");
+    assertNotNull(list);
+  }
+
+  @Test
+  public void testNamedRawSql_with_param() {
+
+    ResetBasicData.reset();
+
+    Query<OrderAggregate> query = Ebean.getDefaultServer().createNamedQuery(OrderAggregate.class, "withParam");
+    List<OrderAggregate> list = query
+      .setParameter("minId", 2)
+      .where().isNotNull("order.id")
+      .having().lt("totalAmount", 100)
+      .order().desc("totalAmount")
+      .setMaxRows(10)
+      .findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as totalItems, sum(order_qty*unit_price) as totalAmount, max(order_qty*unit_price) as maxAmount from o_order_detail");
+    assertThat(query.getGeneratedSql()).contains("from o_order_detail where id > ?  and order_id is not null  group by order_id  having sum(order_qty*unit_price) < ?   order by sum(order_qty*unit_price) desc");
+    assertNotNull(list);
+  }
+}

src/test/java/org/tests/basic/TestOrderTotalAmountSql.java

@@ -0,0 +1,30 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlRow;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestOrderTotalAmountSql extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    String sql = "select order_id, sum(order_qty*unit_price) as total_amount from o_order_detail  where order_qty > :minQty  group by order_id";
+    List<SqlRow> sqlRows = Ebean.createSqlQuery(sql).setParameter("minQty", 1).findList();
+
+    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);
+    }
+  }
+
+}

src/test/java/org/tests/basic/TestPersistenceContext.java

@@ -0,0 +1,81 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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;
+
+public class TestPersistenceContext extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    // implicit transaction with its own
+    // persistence context
+    Order oBefore = Ebean.find(Order.class, 1);
+
+    Order order = null;
+
+    // start a persistence context
+    Ebean.beginTransaction();
+    try {
+
+      order = Ebean.find(Order.class, 1);
+
+      // not the same instance ...as a different
+      // persistence context
+      Assert.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);
+
+      // all the same instance
+      Assert.assertTrue(order == o2);
+      Assert.assertTrue(order == o3);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+
+    // implicit transaction with its own
+    // persistence context
+    Order oAfter = Ebean.find(Order.class, 1);
+
+    Assert.assertTrue(oAfter != oBefore);
+    Assert.assertTrue(oAfter != order);
+
+
+    Order testOrder = ResetBasicData.createOrderCustAndOrder("testPC");
+    Integer id = testOrder.getCustomer().getId();
+    Integer orderId = testOrder.getId();
+
+    // start a persistence context
+    Ebean.beginTransaction();
+    try {
+      Customer customer = Ebean.find(Customer.class)
+        .setUseCache(false)
+        .setId(id)
+        .findUnique();
+
+      System.gc();
+      Order order2 = Ebean.find(Order.class, orderId);
+      Customer customer2 = order2.getCustomer();
+
+      Assert.assertEquals(customer.getId(), customer2.getId());
+
+      Assert.assertTrue(customer == customer2);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+  }
+
+}

src/test/java/org/tests/basic/TestQuery.java

@@ -0,0 +1,47 @@
+package org.tests.basic;
+
+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;
+
+public class TestQuery extends BaseTestCase {
+
+  @Test
+  public void testCountOrderBy() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class).setAutoTune(false).order().asc("orderDate")
+      .order().desc("id");
+    // .orderBy("orderDate");
+
+    int rc = query.findList().size();
+    // int rc = query.findRowCount();
+    Assert.assertTrue(rc > 0);
+    // String generatedSql = query.getGeneratedSql();
+    // Assert.assertFalse(generatedSql.contains("order by"));
+
+  }
+
+  public void testForUpdate() {
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class).setAutoTune(false).setForUpdate(false)
+      .setMaxRows(1).order().asc("orderDate").order().desc("id");
+
+    int rc = query.findList().size();
+    Assert.assertTrue(rc > 0);
+    Assert.assertTrue(!query.getGeneratedSql().toLowerCase().contains("for update"));
+
+    query = Ebean.find(Order.class).setAutoTune(false).setForUpdate(true).setMaxRows(1).order()
+      .asc("orderDate").order().desc("id");
+
+    rc = query.findList().size();
+    Assert.assertTrue(rc > 0);
+    Assert.assertTrue(query.getGeneratedSql().toLowerCase().contains("for update"));
+  }
+}

src/test/java/org/tests/basic/TestQueryWhereBetween.java

@@ -0,0 +1,30 @@
+package org.tests.basic;
+
+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.sql.Timestamp;
+
+public class TestQueryWhereBetween extends BaseTestCase {
+
+  @Test
+  public void testCountOrderBy() {
+
+    ResetBasicData.reset();
+
+    Timestamp t = new Timestamp(System.currentTimeMillis());
+
+    Query<Order> query = Ebean.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"));
+  }
+}

src/test/java/org/tests/basic/TestQueryWithCache.java

@@ -0,0 +1,73 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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.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.*;
+
+public class TestQueryWithCache extends BaseTestCase {
+
+  @Test
+  public void testCountryDeploy() {
+
+    ResetBasicData.reset();
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    BeanDescriptor<Country> beanDescriptor = server.getBeanDescriptor(Country.class);
+    CacheOptions cacheOptions = beanDescriptor.getCacheOptions();
+
+    assertNotNull(cacheOptions);
+    assertTrue(cacheOptions.isReadOnly());
+    assertTrue(beanDescriptor.isCacheSharableBeans());
+
+    ServerCacheManager serverCacheManager = server.getServerCacheManager();
+    serverCacheManager.clear(Country.class);
+
+    ServerCache beanCache = serverCacheManager.getBeanCache(Country.class);
+    assertEquals(0, beanCache.size());
+
+    Country nz1 = Ebean.getReference(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 nz3 = Ebean.find(Country.class, "NZ");
+
+    Country nz4 = Ebean.find(Country.class).setId("NZ").setAutoTune(false).setUseCache(false)
+      .findUnique();
+
+    assertTrue(nz2 == nz2b);
+    assertTrue(nz2 == nz3);
+    assertTrue(nz3 != nz4);
+
+  }
+
+  @Test
+  public void testSkipCache() {
+
+    ResetBasicData.reset();
+
+    Ebean.find(Country.class, "NZ");
+
+    Query<Country> query = Ebean.find(Country.class).setId("NZ").setUseCache(false);
+    query.findUnique();
+
+    assertThat(query.getGeneratedSql()).isNotNull();
+  }
+
+}

src/test/java/org/tests/basic/TestReadOnlyPropagation.java

@@ -0,0 +1,91 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.bean.BeanCollection;
+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.Assert;
+import org.junit.Test;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class TestReadOnlyPropagation extends BaseTestCase {
+
+  @Test
+  public void testReadOnly() {
+
+    ResetBasicData.reset();
+
+    Order order = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .setUseCache(false)
+      .setReadOnly(true)
+      .setId(1)
+      .findUnique();
+
+    Assert.assertTrue(Ebean.getBeanState(order).isReadOnly());
+
+
+    Customer customer = order.getCustomer();
+    Assert.assertTrue(Ebean.getBeanState(customer).isReadOnly());
+
+    Address billingAddress = customer.getBillingAddress();
+    Assert.assertTrue(Ebean.getBeanState(billingAddress).isReadOnly());
+
+
+    List<OrderDetail> details = order.getDetails();
+    BeanCollection<?> bc = (BeanCollection<?>) details;
+
+    Assert.assertTrue(bc.isReadOnly());
+    Assert.assertTrue(!bc.isPopulated());
+
+    bc.size();
+    Assert.assertTrue(!bc.isEmpty());
+    Assert.assertTrue(bc.isReadOnly());
+    Assert.assertTrue(bc.isPopulated());
+    try {
+      details.add(new OrderDetail());
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      details.remove(0);
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      Iterator<OrderDetail> it = details.iterator();
+      it.next();
+      it.remove();
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      ListIterator<OrderDetail> it = details.listIterator();
+      it.next();
+      it.remove();
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      List<OrderDetail> subList = details.subList(0, 1);
+      subList.remove(0);
+      Assert.assertTrue(false);
+    } catch (UnsupportedOperationException e) {
+      Assert.assertTrue(true);
+    }
+
+
+  }
+
+}

src/test/java/org/tests/basic/TestSaveDeleteOneToOne.java

@@ -0,0 +1,38 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PersistentFile;
+import org.tests.model.basic.PersistentFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestSaveDeleteOneToOne extends BaseTestCase {
+
+  @Test
+  public void testCreateDeletePersistentFile() {
+    PersistentFile persistentFile = new PersistentFile("test.txt",
+      new PersistentFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+    Ebean.delete(persistentFile);
+  }
+
+  @Test
+  public void testCreateLoadDeletePersistentFile() {
+    PersistentFile persistentFile = new PersistentFile("test.txt",
+      new PersistentFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+
+    persistentFile = Ebean.find(PersistentFile.class, persistentFile.getId());
+
+    PersistentFileContent persistentFileContent = persistentFile.getPersistentFileContent();
+
+    Assert.assertNotNull(persistentFileContent);
+
+    Assert.assertNotNull("load byte content", persistentFileContent.getContent());
+
+    Ebean.delete(persistentFile);
+  }
+}

src/test/java/org/tests/basic/TestSaveDeleteOneToOneMultiple.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PFile;
+import org.tests.model.basic.PFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestSaveDeleteOneToOneMultiple extends BaseTestCase {
+
+//	public void testCreateDeletePFile() {
+//		PFile persistentFile = new PFile("test.txt",
+//				new PFileContent("test".getBytes()));
+//
+//		Ebean.save(persistentFile);
+//		Ebean.delete(persistentFile);
+//	}
+
+  @Test
+  public void testCreateLoadDeletePFile() {
+    PFile persistentFile = new PFile("test.txt",
+      new PFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+
+    persistentFile = Ebean.find(PFile.class, persistentFile.getId());
+
+    PFileContent persistentFileContent = persistentFile.getFileContent();
+
+    Assert.assertNotNull(persistentFileContent);
+
+    Assert.assertNotNull("load byte content", persistentFileContent.getContent());
+
+    Ebean.delete(persistentFile);
+  }
+}

src/test/java/org/tests/basic/TestSharedInstancePropagation.java

@@ -0,0 +1,63 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.bean.BeanCollection;
+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.*;
+
+public class TestSharedInstancePropagation extends BaseTestCase {
+
+
+  /**
+   * Test that the sharedInstance status is propagated on lazy loading.
+   */
+  @Test
+  public void testSharedListNavigate() {
+
+    ResetBasicData.reset();
+
+    Ebean.getServerCacheManager().clearAll();
+
+    Order order = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .setReadOnly(true)
+      .setId(1)
+      .findUnique();
+
+
+    assertNotNull(order);
+    assertTrue(Ebean.getBeanState(order).isReadOnly());
+
+    List<OrderDetail> details = order.getDetails();
+    BeanCollection<?> bc = (BeanCollection<?>) details;
+    assertTrue(bc.isReadOnly());
+    assertFalse(bc.isPopulated());
+
+    // lazy load
+    bc.size();
+
+    assertTrue(bc.isPopulated());
+    assertTrue(!bc.isEmpty());
+    OrderDetail detail = details.get(0);
+
+    assertTrue(Ebean.getBeanState(detail).isReadOnly());
+    assertFalse(Ebean.getBeanState(detail).isReference());
+
+    Product product = detail.getProduct();
+
+    assertTrue(Ebean.getBeanState(product).isReadOnly());
+
+    // lazy load
+    product.getName();
+    assertFalse(Ebean.getBeanState(product).isReference());
+
+  }
+}

src/test/java/org/tests/basic/TestTransient.java

@@ -0,0 +1,62 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestTransient extends BaseTestCase {
+
+  @Test
+  public void testTransient() {
+
+    Customer cnew = new Customer();
+    cnew.setName("testTrans");
+
+    Ebean.save(cnew);
+    Integer custId = cnew.getId();
+
+    Customer c = Ebean.find(Customer.class).setAutoTune(false).setId(custId).findUnique();
+
+    Assert.assertNotNull(c);
+
+    BeanState beanState = Ebean.getBeanState(c);
+    Assert.assertFalse("not new or dirty as transient", beanState.isNewOrDirty());
+
+    c.getLock().tryLock();
+    try {
+      c.setSelected(Boolean.TRUE);
+    } finally {
+      c.getLock().unlock();
+    }
+
+    Boolean selected = c.getSelected();
+    Assert.assertNotNull(selected);
+
+    Assert.assertFalse("not new or dirty as transient", beanState.isNewOrDirty());
+
+    Ebean.save(c);
+
+    selected = c.getSelected();
+    Assert.assertNotNull(selected);
+
+    c.setName("Modified");
+    Assert.assertTrue("dirty now", beanState.isNewOrDirty());
+
+    selected = c.getSelected();
+    Assert.assertNotNull(selected);
+
+    Ebean.save(c);
+    Assert.assertFalse("Not dirty after save", beanState.isNewOrDirty());
+
+    selected = c.getSelected();
+    Assert.assertNotNull(selected);
+
+    String updateStmt = "update customer set name = 'Rob' where id = :id";
+    int rows = Ebean.createUpdate(Customer.class, updateStmt).set("id", custId).execute();
+
+    Assert.assertTrue("changed name back", 1 == rows);
+  }
+}

src/test/java/org/tests/basic/TestUpdateManyToOne.java

@@ -0,0 +1,40 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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;
+
+public class TestUpdateManyToOne extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    List<Customer> custs = Ebean.find(Customer.class).findList();
+
+    List<Order> orders = Ebean.find(Order.class).setMaxRows(1).findList();
+
+    Order order = orders.get(0);
+    Customer customer = order.getCustomer();
+
+    Customer changeCust = null;
+    for (Customer c : custs) {
+      if (!customer.getId().equals(c.getId())) {
+        changeCust = c;
+        break;
+      }
+    }
+    order.setCustomer(changeCust);
+    Ebean.save(order);
+
+    order.setCustomer(customer);
+    Ebean.save(order);
+
+  }
+}

src/test/java/org/tests/basic/TestUuidInsert.java

@@ -0,0 +1,25 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TUuidEntity;
+import org.junit.Test;
+
+public class TestUuidInsert extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TUuidEntity e = new TUuidEntity();
+    e.setName("bana");
+
+    Ebean.save(e);
+
+    TUuidEntity e2 = Ebean.find(TUuidEntity.class, e.getId());
+    e2.setName("apple");
+
+    Ebean.save(e2);
+
+    Ebean.delete(e2);
+  }
+}

src/test/java/org/tests/basic/TestUuidInsertMasterDetail.java

@@ -0,0 +1,44 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.UUOne;
+import org.tests.model.basic.UUTwo;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class TestUuidInsertMasterDetail extends BaseTestCase {
+
+  @Test
+  public void testInsert() {
+
+    UUTwo two = new UUTwo();
+    two.setName("something");
+
+    ArrayList<UUTwo> list = new ArrayList<>();
+    list.add(two);
+
+    UUOne one = new UUOne();
+    one.setName("some one");
+    one.setComments(list);
+
+    Ebean.save(one);
+
+    UUOne oneB = Ebean.find(UUOne.class, one.getId());
+
+    UUTwo twoB = new UUTwo();
+    twoB.setName("another something");
+    oneB.getComments().add(twoB);
+
+    Ebean.save(oneB);
+  }
+
+  public void testNullFK() {
+
+    UUTwo two = new UUTwo();
+    two.setName("something");
+    Ebean.save(two);
+  }
+
+}

src/test/java/org/tests/basic/TestWhereAnnotation.java

@@ -0,0 +1,34 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+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 TestWhereAnnotation extends BaseTestCase {
+
+  @Test
+  public void testWhere() {
+
+    ResetBasicData.reset();
+    Customer custTest = ResetBasicData.createCustAndOrder("testWhereAnn");
+
+    Customer customer = Ebean.find(Customer.class, custTest.getId());
+    List<Order> orders = customer.getOrders();
+
+    Assert.assertTrue(!orders.isEmpty());
+
+    Query<Customer> q1 = Ebean.find(Customer.class).setUseCache(false).fetch("orders").where()
+      .idEq(1).query();
+
+    q1.findUnique();
+    String s1 = q1.getGeneratedSql();
+    Assert.assertTrue(s1.contains("t1.order_date is not null"));
+  }
+}

src/test/java/org/tests/basic/delete/TestDeleteByIdList.java

@@ -0,0 +1,38 @@
+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);
+
+  }
+}

src/test/java/org/tests/basic/delete/TestDeleteCascadeById.java

@@ -0,0 +1,38 @@
+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);
+
+    Ebean.delete(o);
+
+  }
+}

src/test/java/org/tests/basic/encrypt/BasicEncryptKey.java

@@ -0,0 +1,18 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.config.EncryptKey;
+
+public class BasicEncryptKey implements EncryptKey {
+
+  private final String key;
+
+  public BasicEncryptKey(String key) {
+    this.key = key;
+  }
+
+  public String getStringValue() {
+    return key;
+  }
+
+
+}

src/test/java/org/tests/basic/encrypt/BasicEncyptKeyManager.java

@@ -0,0 +1,20 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.config.EncryptKey;
+import io.ebean.config.EncryptKeyManager;
+
+public class BasicEncyptKeyManager implements EncryptKeyManager {
+
+  /**
+   * Initialise the key manager.
+   */
+  public void initialise() {
+
+  }
+
+  public EncryptKey getEncryptKey(String tableName, String columnName) {
+    // Must be 16 Chars for Oracle function
+    return new BasicEncryptKey("simple0123456789");
+  }
+
+}

src/test/java/org/tests/basic/encrypt/TestEncrypt.java

@@ -0,0 +1,98 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlQuery;
+import io.ebean.SqlRow;
+import io.ebean.Update;
+import io.ebean.config.dbplatform.DbEncrypt;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.tests.model.basic.EBasicEncrypt;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.sql.Date;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestEncrypt extends BaseTestCase {
+
+
+  @Test
+  public void testQueryBind() {
+
+    if (!isH2()) {
+      // only run this on H2 - PGCrypto not happy on CI server
+      return;
+    }
+
+    LoggedSqlCollector.start();
+    Ebean.find(EBasicEncrypt.class)
+      .where().startsWith("description", "Rob")
+      .findList();
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    assertThat(loggedSql).hasSize(1);
+    assertThat(loggedSql.get(0)).contains("; --bind(****,Rob%)");
+  }
+
+  @Ignore
+  @Test
+  public void test() {
+
+    Update<EBasicEncrypt> deleteAll = Ebean.createUpdate(EBasicEncrypt.class, "delete from EBasicEncrypt");
+    deleteAll.execute();
+
+    EBasicEncrypt e = new EBasicEncrypt();
+    e.setName("testname");
+    e.setDescription("testdesc");
+    e.setDob(new Date(System.currentTimeMillis() - 100000));
+
+    Ebean.save(e);
+
+    Date earlyDob = new Date(System.currentTimeMillis() - 500000);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from e_basicenc where id = :id");
+    q.setParameter("id", e.getId());
+
+    SqlRow row = q.findUnique();
+    row.getString("name");
+    row.get("description");
+
+    EBasicEncrypt e1 = Ebean.find(EBasicEncrypt.class, e.getId());
+
+    e1.getDescription();
+
+    e1.setName("testmod");
+    e1.setDescription("moddesc");
+
+    Ebean.save(e1);
+
+    EBasicEncrypt e2 = Ebean.find(EBasicEncrypt.class, e.getId());
+
+    e2.getDescription();
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    DbEncrypt dbEncrypt = server.getDatabasePlatform().getDbEncrypt();
+
+    if (dbEncrypt == null) {
+      // can not test the where clause
+      System.out.println("TestEncrypt: Not testing where clause as no DbEncrypt");
+
+    } else {
+
+      List<EBasicEncrypt> list = Ebean.find(EBasicEncrypt.class).where()
+        .eq("description", "moddesc").findList();
+
+      Assert.assertEquals(1, list.size());
+
+      list = Ebean.find(EBasicEncrypt.class).where().startsWith("description", "modde").findList();
+
+      Assert.assertEquals(1, list.size());
+    }
+  }
+
+}

src/test/java/org/tests/basic/encrypt/TestEncryptBinary.java

@@ -0,0 +1,53 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlQuery;
+import io.ebean.SqlRow;
+import org.tests.model.basic.EBasicEncryptBinary;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+
+public class TestEncryptBinary extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Timestamp t0 = new Timestamp(System.currentTimeMillis());
+    EBasicEncryptBinary e = new EBasicEncryptBinary();
+    e.setName("test1");
+    e.setDescription("testdesc1");
+    e.setSomeTime(t0);
+    e.setData("HelloWorld".getBytes());
+
+    Ebean.save(e);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from e_basicenc_bin where id = :id");
+    q.setParameter("id", e.getId());
+
+    SqlRow row = q.findUnique();
+    row.getString("name");
+    row.get("data");
+    row.get("some_time");
+
+    EBasicEncryptBinary e1 = Ebean.find(EBasicEncryptBinary.class, e.getId());
+
+    Timestamp t1 = e1.getSomeTime();
+    e1.getData();
+
+    e1.getDescription();
+
+    Assert.assertEquals(t0, t1);
+
+    e1.setName("testmod");
+    e1.setDescription("moddesc");
+
+    Ebean.save(e1);
+
+    EBasicEncryptBinary e2 = Ebean.find(EBasicEncryptBinary.class, e.getId());
+    e2.getDescription();
+  }
+
+}

src/test/java/org/tests/basic/event/TestPreInsertValidation.java

@@ -0,0 +1,49 @@
+package org.tests.basic.event;
+
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TWithPreInsert;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestPreInsertValidation extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TWithPreInsert e = new TWithPreInsert();
+    e.setTitle("Mister");
+    // the perInsert should populate the
+    // name with should not be null
+    Ebean.save(e);
+
+    // the save worked and name set in preInsert
+    Assert.assertNotNull(e.getId());
+    Assert.assertNotNull(e.getName());
+
+    TWithPreInsert e1 = Ebean.find(TWithPreInsert.class, e.getId());
+
+    e1.setTitle("Missus");
+    Ebean.save(e1);
+  }
+
+  @Test
+  public void testStatelessUpdate() {
+
+    TWithPreInsert e = new TWithPreInsert();
+    e.setName("BeanForUpdateTest");
+    Ebean.save(e);
+
+    TWithPreInsert bean2 = new TWithPreInsert();
+    bean2.setId(e.getId());
+    bean2.setName("stateless-update-name");
+    bean2.setTitle(null);
+
+    Ebean.update(bean2);
+
+    // title set on preUpdate
+    Assert.assertNotNull(bean2.getTitle());
+  }
+
+}

src/test/java/org/tests/basic/event/TestQueryAdapter.java

@@ -0,0 +1,35 @@
+package org.tests.basic.event;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.ResetBasicData;
+import org.tests.model.basic.TOne;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestQueryAdapter extends BaseTestCase {
+
+  @Test
+  public void testSimple() {
+
+    ResetBasicData.reset();
+
+    TOne o = new TOne();
+    o.setName("something");
+
+    Ebean.save(o);
+
+    //Ebean.find(TOne.class, o.getId());
+
+    Query<TOne> queryFindId = Ebean.find(TOne.class)
+      .setId(o.getId());
+
+    TOne one = queryFindId.findUnique();
+    Assert.assertNotNull(one);
+    Assert.assertEquals(one.getId(), o.getId());
+    String generatedSql = queryFindId.getGeneratedSql();
+    Assert.assertTrue(generatedSql.contains(" 1=1"));
+
+  }
+}

src/test/java/org/tests/basic/join/TestSecondaryJoin.java

@@ -0,0 +1,31 @@
+package org.tests.basic.join;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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;
+
+public class TestSecondaryJoin extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    List<Order> list = Ebean.find(Order.class)
+      // .select("*")
+      // .join("customer")
+      .findList();
+
+    Order o0 = list.get(0);
+    o0.setCustomerName("Banan");
+    o0.setStatus(Status.APPROVED);
+
+    Ebean.save(o0);
+  }
+
+}

src/test/java/org/tests/basic/lob/TestBasicClobFetchEager.java

@@ -0,0 +1,82 @@
+package org.tests.basic.lob;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Query;
+import org.tests.model.basic.EBasicClobFetchEager;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestBasicClobFetchEager extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasicClobFetchEager entity = new EBasicClobFetchEager();
+    entity.setName("test");
+    entity.setDescription("initialClobValue");
+    EbeanServer server = Ebean.getServer(null);
+    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());
+    defaultQuery.findUnique();
+    String sql = trimSql(defaultQuery.getGeneratedSql(), 6);
+
+    assertThat(sql).contains(expectedSql);
+
+
+    LoggedSqlCollector.start();
+
+    // Same as previous query - clob included by default based on annotation
+    Ebean.find(EBasicClobFetchEager.class, entity.getId());
+
+    // Assert query same as previous ...
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.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("*");
+
+    explicitQuery.findUnique();
+    sql = sqlOf(explicitQuery, 6);
+
+    assertThat(sql).contains(expectedSql);
+
+    // Update description to test refresh
+
+    EBasicClobFetchEager updateBean = new EBasicClobFetchEager();
+    updateBean.setId(entity.getId());
+    updateBean.setDescription("modified");
+    Ebean.update(updateBean);
+
+
+    // Test refresh function
+
+    Assert.assertEquals("initialClobValue", entity.getDescription());
+
+    LoggedSqlCollector.start();
+
+    // Refresh query includes all properties
+    server.refresh(entity);
+
+    // Assert all properties fetched in refresh
+    loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+    assertThat(trimSql(loggedSql.get(0), 6)).contains(expectedSql);
+    Assert.assertEquals("modified", entity.getDescription());
+
+  }
+
+}

src/test/java/org/tests/basic/lob/TestBasicClobNoVer.java

@@ -0,0 +1,73 @@
+package org.tests.basic.lob;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Query;
+import org.tests.model.basic.EBasicClobNoVer;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestBasicClobNoVer extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasicClobNoVer entity = new EBasicClobNoVer();
+    entity.setName("test");
+    entity.setDescription("initialClobValue");
+    EbeanServer server = Ebean.getServer(null);
+    server.save(entity);
+
+
+    String sqlNoClob = "select t0.id, t0.name from ebasic_clob_no_ver t0 where t0.id = ?";
+    String sqlWithClob = "select t0.id, t0.name, t0.description from ebasic_clob_no_ver t0 where t0.id = ?";
+
+
+    // Clob by default is Fetch Lazy
+    Query<EBasicClobNoVer> defaultQuery = Ebean.find(EBasicClobNoVer.class).setId(entity.getId());
+    defaultQuery.findUnique();
+    String sql = sqlOf(defaultQuery, 2);
+
+    Assert.assertTrue("Clob is fetch lazy by default", sql.contains(sqlNoClob));
+
+
+    // Explicitly select * including Clob
+    Query<EBasicClobNoVer> explicitQuery = Ebean.find(EBasicClobNoVer.class).setId(entity.getId()).select("*");
+
+    explicitQuery.findUnique();
+    sql = sqlOf(explicitQuery, 2);
+
+    Assert.assertTrue("Explicitly include Clob", sql.contains(sqlWithClob));
+
+    // Update description to test refresh
+
+    EBasicClobNoVer updateBean = new EBasicClobNoVer();
+    updateBean.setId(entity.getId());
+    updateBean.setDescription("modified");
+    Ebean.update(updateBean);
+
+
+    // Test refresh function
+
+    Assert.assertEquals("initialClobValue", entity.getDescription());
+
+    LoggedSqlCollector.start();
+
+    // Refresh query includes all properties
+    server.refresh(entity);
+
+    // Assert all properties fetched in refresh
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+    assertThat(trimSql(loggedSql.get(0), 2)).contains(sqlWithClob);
+    Assert.assertEquals("modified", entity.getDescription());
+
+  }
+
+}

src/test/java/org/tests/basic/lob/TestByteOnly.java

@@ -0,0 +1,27 @@
+package org.tests.basic.lob;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TBytesOnly;
+import org.junit.Test;
+
+public class TestByteOnly extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    byte[] content = new byte[]{1, 1};
+    TBytesOnly e = new TBytesOnly();
+    e.setContent(content);
+
+    Ebean.save(e);
+
+    byte[] content2 = new byte[]{1, 1};
+
+    TBytesOnly e2 = Ebean.find(TBytesOnly.class, e.getId());
+    e2.setContent(content2);
+
+    Ebean.save(e2);
+  }
+
+}

src/test/java/org/tests/basic/one2one/Booking.java

@@ -0,0 +1,92 @@
+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 java.util.List;
+
+@Entity
+@Table(name = "drel_booking")
+public class Booking {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+
+  @Column(unique = true)
+  Long bookingUid;
+
+  @Version
+  private int version;
+
+  @OneToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "agent_invoice")
+  private Invoice agentInvoice;
+
+  @OneToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "client_invoice")
+  private Invoice clientInvoice;
+
+  @OneToMany(mappedBy = "booking")
+  private List<Invoice> invoices;
+
+  public Booking(Long bookingUid) {
+    this.bookingUid = bookingUid;
+  }
+
+  public Long getId() {
+    return id;
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public Long getBookingUid() {
+    return bookingUid;
+  }
+
+  public void setBookingUid(Long bookingUid) {
+    this.bookingUid = bookingUid;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Invoice getAgentInvoice() {
+    return agentInvoice;
+  }
+
+  public void setAgentInvoice(Invoice agentInvoice) {
+    this.agentInvoice = agentInvoice;
+  }
+
+  public Invoice getClientInvoice() {
+    return clientInvoice;
+  }
+
+  public void setClientInvoice(Invoice clientInvoice) {
+    this.clientInvoice = clientInvoice;
+  }
+
+  public List<Invoice> getInvoices() {
+    return invoices;
+  }
+
+  public void setInvoices(List<Invoice> invoices) {
+    this.invoices = invoices;
+  }
+}

src/test/java/org/tests/basic/one2one/Invoice.java

@@ -0,0 +1,51 @@
+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;
+
+@Entity
+@Table(name = "drel_invoice")
+public class Invoice {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+
+  @Version
+  private int version;
+
+  @ManyToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "booking")//_xid", referencedColumnName = "booking_uid")
+  private Booking booking;
+
+  public Long getId() {
+    return id;
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Booking getBooking() {
+    return booking;
+  }
+
+  public void setBooking(Booking booking) {
+    this.booking = booking;
+  }
+}

src/test/java/org/tests/basic/one2one/TestOne2OneBookingInvoice.java

@@ -0,0 +1,46 @@
+package org.tests.basic.one2one;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestOne2OneBookingInvoice extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Booking b = new Booking(3000L);
+
+    Invoice ai = new Invoice();
+    Invoice ci = new Invoice();
+
+    ai.setBooking(b);
+    ci.setBooking(b);
+
+    b.setAgentInvoice(ai);
+    b.setClientInvoice(ci);
+
+    Ebean.save(b);
+
+    Invoice invoice = Ebean.find(Invoice.class, ai.getId());
+    Assert.assertEquals(b.getId(), invoice.getBooking().getId());
+
+    Booking b1 = Ebean.find(Booking.class, b.getId());
+
+    Invoice ai1 = b1.getAgentInvoice();
+    Assert.assertNotNull(ai1);
+
+    Booking b2 = ai1.getBooking();
+    Assert.assertNotNull(b2);
+    Assert.assertEquals(b1.getId(), b2.getId());
+    Assert.assertSame(b1, b2);
+
+    Invoice ci1 = b1.getClientInvoice();
+    Booking b3 = ci1.getBooking();
+    Assert.assertNotNull(b3);
+    Assert.assertEquals(b1.getId(), b2.getId());
+    Assert.assertSame(b1, b2);
+
+  }
+}

src/test/java/org/tests/basic/one2one/TestOneToOneWheelTire.java

@@ -0,0 +1,22 @@
+package org.tests.basic.one2one;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Test;
+
+public class TestOneToOneWheelTire extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Wheel w = new Wheel();
+    Tire t = new Tire();
+    t.setWheel(w);
+    w.setTire(t);
+
+    Ebean.save(t);
+
+    Ebean.delete(t);
+  }
+
+}

src/test/java/org/tests/basic/one2one/Tire.java

@@ -0,0 +1,52 @@
+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;
+
+@Entity
+@Table(name = "tire")
+public class Tire {
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+  @Version
+  private int version;
+  @OneToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "wheel")
+  private Wheel wheel;
+
+  public Tire() {
+    super();
+  }
+
+  public Long getId() {
+    return id;
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Wheel getWheel() {
+    return wheel;
+  }
+
+  public void setWheel(Wheel wheel) {
+    this.wheel = wheel;
+  }
+}

src/test/java/org/tests/basic/one2one/Wheel.java

@@ -0,0 +1,52 @@
+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;
+
+@Entity
+@Table(name = "wheel")
+public class Wheel {
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+
+  @Version
+  private int version;
+
+  @OneToOne(mappedBy = "wheel", cascade = CascadeType.PERSIST)
+  private Tire tire;
+
+  public Long getId() {
+    return id;
+  }
+
+  public Wheel() {
+    super();
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Tire getTire() {
+    return tire;
+  }
+
+  public void setTire(Tire tire) {
+    this.tire = tire;
+  }
+}

src/test/java/org/tests/basic/type/BSimpleWithGen.java

@@ -0,0 +1,44 @@
+package org.tests.basic.type;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Transient;
+import java.util.List;
+import java.util.Map;
+
+@Entity
+public class BSimpleWithGen {
+
+  @Id
+  Integer id;
+
+  String name;
+
+  @Transient
+  Map<String, List<String>> someMap;
+
+  public Integer getId() {
+    return id;
+  }
+
+  public void setId(Integer id) {
+    this.id = id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public Map<String, List<String>> getSomeMap() {
+    return someMap;
+  }
+
+  public void setSomeMap(Map<String, List<String>> someMap) {
+    this.someMap = someMap;
+  }
+
+}

src/test/java/org/tests/basic/type/TestEnumValueAnnotation.java

@@ -0,0 +1,98 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlQuery;
+import io.ebean.SqlRow;
+import org.tests.model.basic.EBasic;
+import org.tests.model.basic.EBasic.Status;
+import org.tests.model.basic.EBasicEnumId;
+import org.tests.model.basic.EBasicEnumInt;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class TestEnumValueAnnotation extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasic b = new EBasic();
+    b.setName("Banana");
+    b.setStatus(Status.NEW);
+
+    Ebean.save(b);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from e_basic where id = :id");
+    q.setParameter("id", b.getId());
+
+    SqlRow sqlRow = q.findUnique();
+    String strStatus = sqlRow.getString("status");
+
+    assertEquals("N", strStatus);
+
+    EBasic b2 = new EBasic();
+    b2.setName("Apple");
+    b2.setStatus(Status.NEW);
+
+    Ebean.save(b2);
+
+    EBasic b3 = Ebean.find(EBasic.class, b2.getId());
+    b3.setName("Orange");
+
+    Ebean.save(b3);
+  }
+
+  @Test
+  public void testAsId() {
+    EBasicEnumId b = new EBasicEnumId();
+    b.setName("Banana");
+    b.setStatus(EBasicEnumId.Status.NEW);
+
+    Ebean.save(b);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from e_basic_enum_id where status = :status");
+    q.setParameter("status", b.getStatus());
+
+    SqlRow sqlRow = q.findUnique();
+    String strStatus = sqlRow.getString("status");
+
+    assertEquals("N", strStatus);
+
+    try {
+      b = Ebean.find(EBasicEnumId.class, b.getStatus());
+    } catch (java.lang.IllegalArgumentException iae) {
+      Assert.fail("The use of an enum as id should work : " + iae.getLocalizedMessage());
+    }
+
+    assertEquals(EBasicEnumId.Status.NEW, b.getStatus());
+  }
+
+  @Test
+  public void testDbEnumValueInt() {
+
+    EBasicEnumInt b = new EBasicEnumInt();
+    b.setName("Banana");
+    b.setStatus(EBasicEnumInt.Status.NEW);
+
+    Ebean.save(b);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from e_basic_eni where id = :id");
+    q.setParameter("id", b.getId());
+
+    SqlRow sqlRow = q.findUnique();
+    Integer intStatus = sqlRow.getInteger("status");
+
+    assertEquals(Integer.valueOf(1), intStatus);
+
+
+    EBasicEnumInt b2 = Ebean.find(EBasicEnumInt.class)
+      .where().eq("id", b.getId())
+      .eq("status", EBasicEnumInt.Status.NEW)
+      .findUnique();
+
+    assertNotNull(b2);
+  }
+}

src/test/java/org/tests/basic/type/TestExtraScalarTypes.java

@@ -0,0 +1,48 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+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;
+
+public class TestExtraScalarTypes extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Locale locale = Locale.getDefault();
+    Currency currency = Currency.getInstance(locale);
+    TimeZone tz = TimeZone.getDefault();
+
+    ESomeType e = new ESomeType();
+    e.setLocale(locale);
+    e.setTimeZone(tz);
+    e.setCurrency(currency);
+
+    Ebean.save(e);
+
+    ESomeType e2 = Ebean.find(ESomeType.class).setAutoTune(false).setId(e.getId()).findUnique();
+
+    Assert.assertNotNull(e2.getCurrency());
+    Assert.assertNotNull(e2.getLocale());
+    Assert.assertNotNull(e2.getTimeZone());
+
+    List<ESomeType> list = Ebean.find(ESomeType.class)
+      .setAutoTune(false).where()
+      .eq("locale", locale)
+      .eq("timeZone", tz.getID())
+      .eq("currency", currency)
+      .findList();
+
+    assertTrue(!list.isEmpty());
+  }
+
+}

src/test/java/org/tests/basic/type/TestInetAddressType.java

@@ -0,0 +1,60 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.EWithInetAddr;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class TestInetAddressType extends BaseTestCase {
+
+  @Test
+  public void testIp4() throws UnknownHostException {
+
+    insertUpdateDeleteFind("120.12.12.56");
+  }
+
+  @Test
+  public void testIp6() throws UnknownHostException {
+
+    insertUpdateDeleteFind("2001:db8:85a3:0:0:8a2e:370:7334");
+  }
+
+  private void insertUpdateDeleteFind(String ipAddress) throws UnknownHostException {
+
+    EWithInetAddr bean1 = new EWithInetAddr();
+    bean1.setName("jim");
+
+    InetAddress address1 = InetAddress.getByName(ipAddress);
+    bean1.setInetAddress(address1);
+
+    Ebean.save(bean1);
+
+    EWithInetAddr bean2 = Ebean.find(EWithInetAddr.class, bean1.getId());
+    InetAddress address2 = bean2.getInetAddress();
+    Assert.assertNotNull(address2.getHostAddress());
+    Assert.assertEquals(address1.getHostAddress(), address2.getHostAddress());
+
+    bean2.setName("modJim");
+    bean2.setInetAddress(InetAddress.getByName("120.12.20.80"));
+    Ebean.save(bean2);
+    Ebean.delete(bean2);
+  }
+
+  @Test
+  public void use_null() throws UnknownHostException {
+
+    EWithInetAddr bean1 = new EWithInetAddr();
+    bean1.setName("jim");
+
+    Ebean.save(bean1);
+
+    EWithInetAddr bean2 = Ebean.find(EWithInetAddr.class, bean1.getId());
+    InetAddress address2 = bean2.getInetAddress();
+    Assert.assertNull(address2);
+  }
+
+}

src/test/java/org/tests/basic/type/TestQueryBooleanProperty.java

@@ -0,0 +1,16 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TOne;
+import org.junit.Test;
+
+public class TestQueryBooleanProperty extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    // when run in MySql is test for BUG 323
+    Ebean.find(TOne.class).where().eq("active", true).findList();
+  }
+}

src/test/java/org/tests/basic/type/TestSqlRowUUID.java

@@ -0,0 +1,34 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlQuery;
+import io.ebean.SqlRow;
+import org.tests.model.basic.TUuidEntity;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.UUID;
+
+public class TestSqlRowUUID extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TUuidEntity e = new TUuidEntity();
+    e.setName("blah");
+
+    Ebean.save(e);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from tuuid_entity where id = :id");
+    q.setParameter("id", e.getId());
+    SqlRow sqlRow = q.findUnique();
+
+    UUID id = sqlRow.getUUID("id");
+
+    Assert.assertNotNull(id);
+
+    Boolean b = sqlRow.getBoolean("name");
+    Assert.assertFalse(b);
+  }
+}

src/test/java/org/tests/basic/type/TestTransientMap.java

@@ -0,0 +1,18 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Test;
+
+public class TestTransientMap extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    BSimpleWithGen b = new BSimpleWithGen();
+    b.setName("blah");
+
+    Ebean.save(b);
+
+  }
+}