Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   package com.j256.ormlite.dao;
   
   import static org.junit.Assert.assertEquals;
   import static org.junit.Assert.assertFalse;
   import static org.junit.Assert.assertNotNull;
   import static org.junit.Assert.assertNotSame;
   import static org.junit.Assert.assertNull;
   import static org.junit.Assert.assertSame;
   import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  
  import java.util.Arrays;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.UUID;
  
  import org.junit.Test;
  
  
  public class JdbcBaseDaoImplTest extends BaseJdbcTest {
  
  	private static final boolean CLOSE_IS_NOOP = false;
  	private static final boolean UPDATE_ROWS_RETURNS_ONE = false;
  
  	protected boolean isTableExistsWorks() {
  		return true;
  	}
  
  	/* ======================================================================================== */
  
  	private final static String DEFAULT_VALUE_STRING = "1314199";
  	private final static int DEFAULT_VALUE = Integer.parseInt();
  	private final static int ALL_TYPES_STRING_WIDTH = 4;
  	protected final static String FOO_TABLE_NAME = "footable";
  	private final static String ENUM_TABLE_NAME = "enumtable";
  
  	private final static String NULL_BOOLEAN_TABLE_NAME = "nullbooltable";
  	private final static String NULL_INT_TABLE_NAME = "nullinttable";
  
  	private final static String DEFAULT_BOOLEAN_VALUE = "true";
  	private final static String DEFAULT_STRING_VALUE = "foo";
  	// this can't have non-zero milliseconds
  	private final static String DEFAULT_DATE_VALUE = "2010-07-16 01:31:17.000000";
  	private final static String DEFAULT_DATE_LONG_VALUE = "1282768620000";
  	private final static String DEFAULT_DATE_STRING_FORMAT = "MM/dd/yyyy HH-mm-ss-SSSSSS";
  	private final static String DEFAULT_DATE_STRING_VALUE = "07/16/2010 01-31-17-000000";
  	private final static String DEFAULT_BYTE_VALUE = "1";
  	private final static String DEFAULT_SHORT_VALUE = "2";
  	private final static String DEFAULT_INT_VALUE = "3";
  	private final static String DEFAULT_LONG_VALUE = "4";
  	private final static String DEFAULT_FLOAT_VALUE = "5";
  	private final static String DEFAULT_DOUBLE_VALUE = "6";
  	private final static String DEFAULT_ENUM_VALUE = "FIRST";
  	private final static String DEFAULT_ENUM_NUMBER_VALUE = "1";
  
  	@Test
  	public void testCreateDaoStatic() throws Exception {
  		if ( == null) {
  			return;
  		}
  		createTable(Foo.classtrue);
  		Dao<FooIntegerfooDao = DaoManager.createDao(Foo.class);
  		String stuff = "stuff";
  		Foo foo = new Foo();
  		foo.stuff = stuff;
  		assertEquals(1, fooDao.create(foo));
  
  		// now we query for foo from the database to make sure it was persisted right
  		Foo foo2 = fooDao.queryForId(foo.id);
  		assertNotNull(foo2);
  		assertEquals(foo.idfoo2.id);
  		assertEquals(stufffoo2.stuff);
 	}
 
 	public void testCreateUpdateDelete() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		String s1 = "stuff";
 		Foo foo1 = new Foo();
 		foo1.stuff = s1;
 		assertEquals(0, foo1.id);
 
 		// persist foo to db through the dao and sends the id on foo because it was auto-generated by the db
 		assertEquals(1, fooDao.create(foo1));
 		assertTrue(foo1.id != 0);
 		assertEquals(s1foo1.stuff);
 
 		// now we query for foo from the database to make sure it was persisted right
 		Foo foo2 = fooDao.queryForId(foo1.id);
 		assertEquals(foo1.idfoo2.id);
 		assertEquals(s1foo2.stuff);
 
 		String s2 = "stuff2";
 		foo2.stuff = s2;
 
 		// now we update 1 row in a the database after changing foo
 		assertEquals(1, fooDao.update(foo2));
 
 		// now we get it from the db again to make sure it was updated correctly
 		Foo foo3 = fooDao.queryForId(foo1.id);
 		assertEquals(s2foo3.stuff);
 		assertEquals(1, fooDao.delete(foo2));
 
 		assertNull(fooDao.queryForId(foo1.id));
 	}
 
 	public void testDoubleCreate() throws Exception {
 		Dao<DoubleCreateObjectdoubleDao = createDao(DoubleCreate.classtrue);
 		int id = 313413123;
 		DoubleCreate foo = new DoubleCreate();
 		foo.id = id;
 		assertEquals(1, doubleDao.create(foo));
 		try {
 			doubleDao.create(foo);
 			fail("expected exception");
 		} catch (SQLException e) {
 			// expected
 		}
 	}
 
 	public void testIterateRemove() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		List<FooacctList = fooDao.queryForAll();
 		int initialSize = acctList.size();
 
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		Foo foo2 = new Foo();
 		foo2.stuff = "s2";
 		Foo foo3 = new Foo();
 		foo3.stuff = "s3";
 		fooDao.create(foo1);
 		fooDao.create(foo2);
 		fooDao.create(foo3);
 
 		assertTrue(foo1.id != foo2.id);
 		assertTrue(foo1.id != foo3.id);
 		assertTrue(foo2.id != foo3.id);
 
 		assertEquals(foo1fooDao.queryForId(foo1.id));
 		assertEquals(foo2fooDao.queryForId(foo2.id));
 		assertEquals(foo3fooDao.queryForId(foo3.id));
 
 		acctList = fooDao.queryForAll();
 		assertEquals(initialSize + 3, acctList.size());
 		assertEquals(foo1acctList.get(acctList.size() - 3));
 		assertEquals(foo2acctList.get(acctList.size() - 2));
 		assertEquals(foo3acctList.get(acctList.size() - 1));
 		int acctC = 0;
 		Iterator<Fooiterator = fooDao.iterator();
 		while (iterator.hasNext()) {
 			Foo foo = iterator.next();
 			if (acctC == acctList.size() - 3) {
 				assertEquals(foo1foo);
 			} else if (acctC == acctList.size() - 2) {
 				iterator.remove();
 				assertEquals(foo2foo);
 			} else if (acctC == acctList.size() - 1) {
 				assertEquals(foo3foo);
 			}
 			acctC++;
 		}
 		assertEquals(initialSize + 3, acctC);
 	}
 
 	public void testGeneratedField() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		assertEquals(0, foo1.id);
 		assertEquals(1, fooDao.create(foo1));
 		assertTrue(foo1.id != 0);
 	}
 
 	public void testGeneratedIdNotNullField() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		assertEquals(0, foo1.id);
 		assertEquals(1, fooDao.create(foo1));
 		assertTrue(foo1.id != 0);
 	}
 
 	public void testObjectToString() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		String stuff = "foo123231";
 		Foo foo1 = new Foo();
 		foo1.stuff = stuff;
 		String objStr = fooDao.objectToString(foo1);
 		assertTrue(objStr.contains(Integer.toString(foo1.id)));
 		assertTrue(objStr.contains(stuff));
 	}
 
 	public void testCreateNull() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		assertEquals(0, fooDao.create((Foonull));
 	}
 
 	public void testUpdateNull() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		assertEquals(0, fooDao.update((Foonull));
 	}
 
 	public void testUpdateIdNull() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		assertEquals(0, fooDao.updateId(nullnull));
 	}
 
 	public void testDeleteNull() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		assertEquals(0, fooDao.delete((Foonull));
 	}
 
 	public void testCloseInIterator() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		fooDao.create(foo1);
 		Iterator<Fooiterator = fooDao.iterator();
 		try {
 			while (iterator.hasNext()) {
 				iterator.next();
 			}
 			if (!) {
 				fail("expected exception");
 			}
 		} catch (IllegalStateException e) {
 			// expected
 		}
 	}
 
 	public void testCloseIteratorFirst() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		fooDao.create(foo1);
 		try {
 			fooDao.iterator();
 			fail("expected exception");
 		} catch (IllegalStateException e) {
 			// expected
 		}
 	}
 
 	public void testCloseIteratorBeforeNext() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		fooDao.create(foo1);
 		CloseableIterator<Fooiterator = fooDao.iterator();
 		try {
 			while (iterator.hasNext()) {
 				iterator.next();
 			}
 			if (!) {
 				fail("expected exception");
 			}
 		} catch (IllegalStateException e) {
 			// expected
 		} finally {
 			iterator.close();
 		}
 	}
 
 	public void testCloseIteratorBeforeRemove() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		fooDao.create(foo1);
 		CloseableIterator<Fooiterator = fooDao.iterator();
 		try {
 			while (iterator.hasNext()) {
 				iterator.next();
 				iterator.remove();
 			}
 			fail("expected exception");
 		} catch (Exception e) {
 			// expected
 		}
 	}
 
 	public void testNoNextBeforeRemove() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		fooDao.create(foo1);
 		CloseableIterator<Fooiterator = fooDao.iterator();
 		try {
 			iterator.remove();
 			fail("expected exception");
 		} catch (IllegalStateException e) {
 			// expected
 		} finally {
 			iterator.close();
 		}
 	}
 
 	public void testIteratePageSize() throws Exception {
 		final Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 
 		int numItems = 1000;
 		fooDao.callBatchTasks(new InsertCallable(numItemsfooDao));
 
 		// now delete them with the iterator to test page-size
 		Iterator<Fooiterator = fooDao.iterator();
 		while (iterator.hasNext()) {
 			iterator.next();
 			iterator.remove();
 		}
 	}
 
 	public void testIteratorPreparedQuery() throws Exception {
 		final Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		// do an insert of bunch of items
 		final int numItems = 100;
 		fooDao.callBatchTasks(new InsertCallable(numItemsfooDao));
 
 		int lastX = 10;
 		PreparedQuery<FoopreparedQuery =
 				fooDao.queryBuilder().where().ge(.numItems - lastX).prepare();
 
 		// now delete them with the iterator to test page-size
 		Iterator<Fooiterator = fooDao.iterator(preparedQuery);
 		int itemC = 0;
 		while (iterator.hasNext()) {
 			Foo foo = iterator.next();
 			..println("Foo = " + foo.val);
 			itemC++;
 		}
 		assertEquals(lastXitemC);
 	}
 
 	private static class InsertCallable implements Callable<Void> {
 		private int numItems;
 		private Dao<FooIntegerfooDao;
 		public InsertCallable(int numItemsDao<FooIntegerfooDao) {
 			this. = numItems;
 			this. = fooDao;
 		}
 		public Void call() throws Exception {
 			for (int i = 0; i < i++) {
 				Foo foo = new Foo();
 				foo.val = i;
 			}
 			return null;
 		}
 	}
 
 	public void testDeleteObjects() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		List<FoofooList = new ArrayList<Foo>();
 		for (int i = 0; i < 100; i++) {
 			Foo foo = new Foo();
 			foo.stuff = Integer.toString(i);
 			assertEquals(1, fooDao.create(foo));
 			fooList.add(foo);
 		}
 
 		int deleted = fooDao.delete(fooList);
 			assertEquals(1, deleted);
 		} else {
 			assertEquals(fooList.size(), deleted);
 		}
 		assertEquals(0, fooDao.queryForAll().size());
 	}
 
 	public void testDeleteObjectsNone() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		List<FoofooList = new ArrayList<Foo>();
 		assertEquals(fooList.size(), fooDao.delete(fooList));
 		assertEquals(0, fooDao.queryForAll().size());
 	}
 
 	public void testDeleteIds() throws Exception {
 		final Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		final List<IntegerfooIdList = new ArrayList<Integer>();
 		fooDao.callBatchTasks(new Callable<Void>() {
 			public Void call() throws Exception {
 				for (int i = 0; i < 100; i++) {
 					Foo foo = new Foo();
 					assertEquals(1, fooDao.create(foo));
 					fooIdList.add(foo.id);
 				}
 				return null;
 			}
 		});
 
 		int deleted = fooDao.deleteIds(fooIdList);
 			assertEquals(1, deleted);
 		} else {
 			assertEquals(fooIdList.size(), deleted);
 		}
 		assertEquals(0, fooDao.queryForAll().size());
 	}
 
 	public void testDeleteIdsNone() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		List<IntegerfooIdList = new ArrayList<Integer>();
 		assertEquals(fooIdList.size(), fooDao.deleteIds(fooIdList));
 		assertEquals(0, fooDao.queryForAll().size());
 	}
 
 	public void testDeletePreparedStmtIn() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		List<IntegerfooIdList = new ArrayList<Integer>();
 		for (int i = 0; i < 100; i++) {
 			Foo foo = new Foo();
 			assertEquals(1, fooDao.create(foo));
 			fooIdList.add(foo.id);
 		}
 
 		DeleteBuilder<FooIntegerstmtBuilder = fooDao.deleteBuilder();
 		stmtBuilder.where().in(.fooIdList);
 
 		int deleted = fooDao.delete(stmtBuilder.prepare());
 			assertEquals(1, deleted);
 		} else {
 			assertEquals(fooIdList.size(), deleted);
 		}
 		assertEquals(0, fooDao.queryForAll().size());
 	}
 
 	public void testDeleteAllPreparedStmt() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		int fooN = 100;
 		for (int i = 0; i < fooNi++) {
 			Foo foo = new Foo();
 			assertEquals(1, fooDao.create(foo));
 		}
 
 		DeleteBuilder<FooIntegerstmtBuilder = fooDao.deleteBuilder();
 
 		int deleted = fooDao.delete(stmtBuilder.prepare());
 			assertEquals(1, deleted);
 		} else {
 			assertEquals(fooNdeleted);
 		}
 		assertEquals(0, fooDao.queryForAll().size());
 	}
 
 	public void testHasNextAfterDone() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Iterator<Fooiterator = fooDao.iterator();
 		while (iterator.hasNext()) {
 		}
 		assertFalse(iterator.hasNext());
 	}
 
 	public void testNextWithoutHasNext() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Iterator<Fooiterator = fooDao.iterator();
 		try {
 			iterator.next();
 			fail("expected exception");
 		} catch (Exception e) {
 			// expected
 		}
 	}
 
 	public void testRemoveAfterDone() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Iterator<Fooiterator = fooDao.iterator();
 		assertFalse(iterator.hasNext());
 		try {
 			iterator.remove();
 			fail("expected exception");
 		} catch (IllegalStateException e) {
 			// expected
 		}
 	}
 
 	public void testIteratorNoResults() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		Iterator<Fooiterator = fooDao.iterator();
 		assertFalse(iterator.hasNext());
 		assertNull(iterator.next());
 	}
 
 	public void testCreateNoId() throws Exception {
 		Dao<NoIdObjectwhereDao = createDao(NoId.classtrue);
 		NoId noId = new NoId();
 		assertEquals(0, whereDao.queryForAll().size());
 		// this should work even though there is no id
 		whereDao.create(noId);
 		assertEquals(1, whereDao.queryForAll().size());
 	}
 
 	public void testJustIdCreateQueryDelete() throws Exception {
 		Dao<JustIdObjectjustIdDao = createDao(JustId.classtrue);
 		String id = "just-id";
 		JustId justId = new JustId();
 		justId.id = id;
 		assertEquals(1, justIdDao.create(justId));
 		JustId justId2 = justIdDao.queryForId(id);
 		assertNotNull(justId2);
 		assertEquals(idjustId2.id);
 		assertEquals(1, justIdDao.delete(justId));
 		assertNull(justIdDao.queryForId(id));
 		// update should fail during construction
 	}
 
 	public void testJustIdUpdateId() throws Exception {
 		Dao<JustIdObjectjustIdDao = createDao(JustId.classtrue);
 		String id = "just-id-update-1";
 		JustId justId = new JustId();
 		justId.id = id;
 		assertEquals(1, justIdDao.create(justId));
 		JustId justId2 = justIdDao.queryForId(id);
 		assertNotNull(justId2);
 		assertEquals(idjustId2.id);
 		String id2 = "just-id-update-2";
 		// change the id
 		assertEquals(1, justIdDao.updateId(justId2id2));
 		assertNull(justIdDao.queryForId(id));
 		JustId justId3 = justIdDao.queryForId(id2);
 		assertNotNull(justId3);
 		assertEquals(id2justId3.id);
 		assertEquals(1, justIdDao.delete(justId3));
 		assertNull(justIdDao.queryForId(id));
 		assertNull(justIdDao.queryForId(id2));
 	}
 
 	public void testJustIdRefresh() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		String stuff1 = "just-id-refresh-1";
 		Foo foo1 = new Foo();
 		foo1.stuff = stuff1;
 		assertEquals(1, fooDao.create(foo1));
 		int id = foo1.id;
 		Foo foo2 = fooDao.queryForId(id);
 		assertEquals(idfoo2.id);
 		assertEquals(stuff1foo2.stuff);
 		String stuff2 = "just-id-refresh-2";
 		foo2.stuff = stuff2;
 
 		// change the id in the db
 		assertEquals(1, fooDao.update(foo2));
 		Foo foo3 = fooDao.queryForId(id);
 		assertEquals(idfoo3.id);
 		assertEquals(stuff2foo3.stuff);
 
 		assertEquals(stuff1foo1.stuff);
 		assertEquals(1, fooDao.refresh(foo1));
 		assertEquals(stuff2foo1.stuff);
 	}
 
 	public void testSpringConstruction() throws Exception {
 		if ( == null) {
 			return;
 		}
 		createTable(Foo.classtrue);
 		BaseDaoImpl<FooIntegerfooDao = new BaseDaoImpl<FooInteger>(Foo.class) {
 		};
 		try {
 			fooDao.create(new Foo());
 			fail("expected exception");
 		} catch (IllegalStateException e) {
 			// expected
 		}
 		fooDao.initialize();
 		Foo foo = new Foo();
 		assertEquals(1, fooDao.create(foo));
 		assertEquals(1, fooDao.delete(foo));
 	}
 
 	public void testForeignCreation() throws Exception {
 		Dao<ForeignWrapperIntegerwrapperDao = createDao(ForeignWrapper.classtrue);
 		Dao<AllTypesIntegerforeignDao = createDao(AllTypes.classtrue);
 
 		AllTypes foreign = new AllTypes();
 		String stuff1 = "stuff1";
 		foreign.stringField = stuff1;
 		// this sets the foreign id
 		assertEquals(1, foreignDao.create(foreign));
 
 		ForeignWrapper wrapper = new ForeignWrapper();
 		wrapper.foreign = foreign;
 		// this sets the wrapper id
 		assertEquals(1, wrapperDao.create(wrapper));
 
 		ForeignWrapper wrapper2 = wrapperDao.queryForId(wrapper.id);
 		assertEquals(wrapper.idwrapper2.id);
 		assertEquals(wrapper.foreign.idwrapper2.foreign.id);
 		assertTrue(wrapperDao.objectsEqual(wrapperwrapper2));
 		// this won't be true because wrapper2.foreign is a shell
 		assertFalse(foreignDao.objectsEqual(foreignwrapper2.foreign));
 		assertNull(wrapper2.foreign.stringField);
 		assertEquals(1, foreignDao.refresh(wrapper2.foreign));
 		// now it should be true
 		assertTrue(foreignDao.objectsEqual(foreignwrapper2.foreign));
 		assertEquals(stuff1wrapper2.foreign.stringField);
 
 		// create a new foreign
 		foreign = new AllTypes();
 		String stuff2 = "stuff2";
 		foreign.stringField = stuff2;
 		// this sets the foreign id
 		assertEquals(1, foreignDao.create(foreign));
 
 		// change the foreign object
 		wrapper.foreign = foreign;
 		// update it
 		assertEquals(1, wrapperDao.update(wrapper));
 
 		wrapper2 = wrapperDao.queryForId(wrapper.id);
 		assertEquals(wrapper.idwrapper2.id);
 		assertEquals(wrapper.foreign.idwrapper2.foreign.id);
 		assertTrue(wrapperDao.objectsEqual(wrapperwrapper2));
 		// this won't be true because wrapper2.foreign is a shell
 		assertFalse(foreignDao.objectsEqual(foreignwrapper2.foreign));
 		assertNull(wrapper2.foreign.stringField);
 		assertEquals(1, foreignDao.refresh(wrapper2.foreign));
 		// now it should be true
 		assertTrue(foreignDao.objectsEqual(foreignwrapper2.foreign));
 		assertEquals(stuff2wrapper2.foreign.stringField);
 	}
 
 	public void testForeignRefreshNoChange() throws Exception {
 		Dao<ForeignWrapperIntegerwrapperDao = createDao(ForeignWrapper.classtrue);
 		Dao<AllTypesIntegerforeignDao = createDao(AllTypes.classtrue);
 
 		AllTypes foreign = new AllTypes();
 		String stuff1 = "stuff1";
 		foreign.stringField = stuff1;
 		// this sets the foreign id
 		assertEquals(1, foreignDao.create(foreign));
 
 		ForeignWrapper wrapper = new ForeignWrapper();
 		wrapper.foreign = foreign;
 		// this sets the wrapper id
 		assertEquals(1, wrapperDao.create(wrapper));
 
 		ForeignWrapper wrapper2 = wrapperDao.queryForId(wrapper.id);
 		assertEquals(1, foreignDao.refresh(wrapper2.foreign));
 		AllTypes foreign2 = wrapper2.foreign;
 		assertEquals(stuff1foreign2.stringField);
 
 		assertEquals(1, wrapperDao.refresh(wrapper2));
 		assertSame(foreign2wrapper2.foreign);
 		assertEquals(stuff1wrapper2.foreign.stringField);
 
 		// now, in the background, we change the foreign
 		ForeignWrapper wrapper3 = wrapperDao.queryForId(wrapper.id);
 		AllTypes foreign3 = new AllTypes();
 		String stuff3 = "stuff3";
 		foreign3.stringField = stuff3;
 		assertEquals(1, foreignDao.create(foreign3));
 		wrapper3.foreign = foreign3;
 		assertEquals(1, wrapperDao.update(wrapper3));
 
 		assertEquals(1, wrapperDao.refresh(wrapper2));
 		// now all of a sudden wrapper2 should not have the same foreign field
 		assertNotSame(foreign2wrapper2.foreign);
 		assertNull(wrapper2.foreign.stringField);
 	}
 
 	public void testMultipleForeignWrapper() throws Exception {
 		Dao<MultipleForeignWrapperIntegermultipleWrapperDao = createDao(MultipleForeignWrapper.classtrue);
 		Dao<ForeignWrapperIntegerwrapperDao = createDao(ForeignWrapper.classtrue);
 		Dao<AllTypesIntegerforeignDao = createDao(AllTypes.classtrue);
 
 		AllTypes foreign = new AllTypes();
 		String stuff1 = "stuff1";
 		foreign.stringField = stuff1;
 		// this sets the foreign id
 		assertEquals(1, foreignDao.create(foreign));
 
 		ForeignWrapper wrapper = new ForeignWrapper();
 		wrapper.foreign = foreign;
 		// this sets the wrapper id
 		assertEquals(1, wrapperDao.create(wrapper));
 
 		multiWrapper.foreign = foreign;
 		multiWrapper.foreignWrapper = wrapper;
 		// this sets the wrapper id
 		assertEquals(1, multipleWrapperDao.create(multiWrapper));
 
 		MultipleForeignWrapper multiWrapper2 = multipleWrapperDao.queryForId(multiWrapper.id);
 		assertEquals(foreign.idmultiWrapper2.foreign.id);
 		assertNull(multiWrapper2.foreign.stringField);
 		assertEquals(wrapper.idmultiWrapper2.foreignWrapper.id);
 		assertNull(multiWrapper2.foreignWrapper.foreign);
 
 		assertEquals(1, foreignDao.refresh(multiWrapper2.foreign));
 		assertEquals(stuff1multiWrapper2.foreign.stringField);
 		assertNull(multiWrapper2.foreignWrapper.foreign);
 
 		assertEquals(1, wrapperDao.refresh(multiWrapper2.foreignWrapper));
 		assertEquals(foreign.idmultiWrapper2.foreignWrapper.foreign.id);
 		assertNull(multiWrapper2.foreignWrapper.foreign.stringField);
 
 		assertEquals(1, foreignDao.refresh(multiWrapper2.foreignWrapper.foreign));
 		assertEquals(stuff1multiWrapper2.foreignWrapper.foreign.stringField);
 	}
 
 	public void testRefreshNull() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 		// this should be a noop
 		assertEquals(0, fooDao.refresh(null));
 	}
 
 	public void testGetSet() throws Exception {
 		Dao<GetSetIntegergetSetDao = createDao(GetSet.classtrue);
 		GetSet getSet = new GetSet();
 		String stuff = "ewfewfewfew343u42f";
 		getSet.setStuff(stuff);
 		assertEquals(1, getSetDao.create(getSet));
 		GetSet getSet2 = getSetDao.queryForId(getSet.id);
 		assertEquals(stuffgetSet2.stuff);
 	}
 
 	public void testQueryForFirst() throws Exception {
 		Dao<FooIntegerfooDao = createDao(Foo.classtrue);
 
 		String stuff = "ewf4334234u42f";
 
 		QueryBuilder<FooIntegerqb = fooDao.queryBuilder();
 		qb.where().eq(.stuff);
 
 
 		Foo foo1 = new Foo();
 		foo1.stuff = stuff;
 		assertEquals(1, fooDao.create(foo1));
 
 		// should still get foo1
 		Foo foo2 = fooDao.queryForFirst(qb.prepare());
 		assertEquals(foo1.idfoo2.id);
 		assertEquals(stufffoo2.stuff);
 
 		// create another with same stuff
 		Foo foo3 = new Foo();
 		String stuff2 = "ewf43342wefwffwefwe34u42f";
 		foo3.stuff = stuff2;
 		assertEquals(1, fooDao.create(foo3));
 
 		foo2 = fooDao.queryForFirst(qb.prepare());
 		assertEquals(foo1.idfoo2.id);
 		assertEquals(stufffoo2.stuff);
 	}
 
 	public void testFieldConfig() throws Exception {
 		fieldConfigs.add(new DatabaseFieldConfig("id""id2".null, 0, falsefalsetruenull,
 				falsenullfalsenullfalsenullfalsenullnullfalse, 0, 0));
 		fieldConfigs.add(new DatabaseFieldConfig("stuff""stuffy".null, 0, falsefalsefalse,
 				nullfalsenullfalsenullfalsenullfalsenullnullfalse, 0, 0));
 		DatabaseTableConfig<NoAnnotableConfig = new DatabaseTableConfig<NoAnno>(NoAnno.class"noanno"fieldConfigs);
 		Dao<NoAnnoIntegernoAnnotaionDao = createDao(tableConfigtrue);
 		NoAnno noa = new NoAnno();
 		String stuff = "qpoqwpjoqwp12";
 		noa.stuff = stuff;
 		assertEquals(1, noAnnotaionDao.create(noa));
 		NoAnno noa2 = noAnnotaionDao.queryForId(noa.id);
 		assertEquals(noa.idnoa2.id);
 		assertEquals(stuffnoa2.stuff);
 	}
 
 	public void testFieldConfigForeign() throws Exception {
 		List<DatabaseFieldConfignoAnnotationsFieldConfigs = new ArrayList<DatabaseFieldConfig>();
 		DatabaseFieldConfig field1 = new DatabaseFieldConfig("id");
 		field1.setColumnName("idthingie");
 		field1.setGeneratedId(true);
 		noAnnotationsFieldConfigs.add(field1);
 		DatabaseFieldConfig field2 = new DatabaseFieldConfig("stuff");
 		field2.setColumnName("stuffy");
 		noAnnotationsFieldConfigs.add(field2);
 		DatabaseTableConfig<NoAnnonoAnnotationsTableConfig =
 				new DatabaseTableConfig<NoAnno>(NoAnno.classnoAnnotationsFieldConfigs);
 		Dao<NoAnnoIntegernoAnnotationDao = createDao(noAnnotationsTableConfigtrue);
 		NoAnno noa = new NoAnno();
 		String stuff = "qpoqwpjoqwp12";
 		noa.stuff = stuff;
 		assertEquals(1, noAnnotationDao.create(noa));
 		assertNotNull(noAnnotationDao.queryForId(noa.id));
 
 		List<DatabaseFieldConfignoAnnotationsForiegnFieldConfigs = new ArrayList<DatabaseFieldConfig>();
 		DatabaseFieldConfig field3 = new DatabaseFieldConfig("id");
 		field3.setColumnName("anotherid");
 		field3.setGeneratedId(true);
 		noAnnotationsForiegnFieldConfigs.add(field3);
 		DatabaseFieldConfig field4 = new DatabaseFieldConfig("foreign");
 		field4.setColumnName("foreignThingie");
 		field4.setForeign(true);
 		field4.setForeignTableConfig(noAnnotationsTableConfig);
 		noAnnotationsForiegnFieldConfigs.add(field4);
 		DatabaseTableConfig<NoAnnoFornoAnnotationsForiegnTableConfig =
 				new DatabaseTableConfig<NoAnnoFor>(NoAnnoFor.classnoAnnotationsForiegnFieldConfigs);
 
 		Dao<NoAnnoForIntegernoAnnotaionForeignDao = createDao(noAnnotationsForiegnTableConfigtrue);
 		NoAnnoFor noaf = new NoAnnoFor();
 		noaf.foreign = noa;
 		assertEquals(1, noAnnotaionForeignDao.create(noaf));
 
 		NoAnnoFor noaf2 = noAnnotaionForeignDao.queryForId(noaf.id);
 		assertNotNull(noaf2);
 		assertEquals(noaf.idnoaf2.id);
 		assertEquals(noa.idnoaf2.foreign.id);
 		assertNull(noaf2.foreign.stuff);
 		assertEquals(1, noAnnotationDao.refresh(noaf2.foreign));
 		assertEquals(stuffnoaf2.foreign.stuff);
 	}
 
 	public void testGeneratedIdNotNull() throws Exception {
 		// we saw an error with the not null before the generated id stuff under hsqldb
 	}
 
 	public void testBasicStuff() throws Exception {
 		Dao<BasicStringfooDao = createDao(Basic.classtrue);
 
 		String string = "s1";
 		Basic foo1 = new Basic();
 		foo1.id = string;
 		assertEquals(1, fooDao.create(foo1));
 
 		Basic foo2 = fooDao.queryForId(string);
 		assertTrue(fooDao.objectsEqual(foo1foo2));
 
 		List<BasicfooList = fooDao.queryForAll();
 		assertEquals(1, fooList.size());
 		assertTrue(fooDao.objectsEqual(foo1fooList.get(0)));
 		int i = 0;
 		for (Basic foo3 : fooDao) {
 			assertTrue(fooDao.objectsEqual(foo1foo3));
 			i++;
 		}
 		assertEquals(1, i);
 
 		assertEquals(1, fooDao.delete(foo2));
 		assertNull(fooDao.queryForId(string));
 		fooList = fooDao.queryForAll();
 		assertEquals(0, fooList.size());
 		i = 0;
 		for (Basic foo3 : fooDao) {
 			assertTrue(fooDao.objectsEqual(foo1foo3));
 			i++;
 		}
 		assertEquals(0, i);
 	}
 
 	public void testMultiplePrimaryKey() throws Exception {
 		Dao<BasicStringfooDao = createDao(Basic.classtrue);
 		Basic foo1 = new Basic();
 		foo1.id = "dup";
 		assertEquals(1, fooDao.create(foo1));
 		try {
 			fooDao.create(foo1);
 			fail("expected exception");
 		} catch (SQLException e) {
 			// expected
 		}
 	}
 
 	public void testDefaultValue() throws Exception {
 		Dao<DefaultValueObjectdefValDao = createDao(DefaultValue.classtrue);
 		DefaultValue defVal1 = new DefaultValue();
 		assertEquals(1, defValDao.create(defVal1));
 		List<DefaultValuedefValList = defValDao.queryForAll();
 		assertEquals(1, defValList.size());
 		DefaultValue defVal2 = defValList.get(0);
 		assertEquals(, (intdefVal2.intField);
 	}
 
 	public void testNotNull() throws Exception {
 		Dao<NotNullObjectdefValDao = createDao(NotNull.classtrue);
 		NotNull notNull = new NotNull();
 		try {
 			defValDao.create(notNull);
 			fail("expected exception");
 		} catch (SQLException e) {
 			// expected
 		}
 	}
 
 	public void testNotNullOkay() throws Exception {
 		Dao<NotNullObjectdefValDao = createDao(NotNull.classtrue);
 		NotNull notNull = new NotNull();
 		notNull.notNull = "not null";
 		assertEquals(1, defValDao.create(notNull));
 	}
 
 	public void testGeneratedId() throws Exception {
 		Dao<GeneratedIdObjectgenIdDao = createDao(GeneratedId.classtrue);
 		GeneratedId genId = new GeneratedId();
 		assertEquals(0, genId.id);
 		assertEquals(1, genIdDao.create(genId));
 		long id = genId.id;
 		assertEquals(1, id);
 		GeneratedId genId2 = genIdDao.queryForId(id);
 		assertNotNull(genId2);
 		assertEquals(idgenId2.id);
 
 		genId = new GeneratedId();
 		assertEquals(0, genId.id);
 		assertEquals(1, genIdDao.create(genId));
 		id = genId.id;
 		assertEquals(2, id);
 		genId2 = genIdDao.queryForId(id);
 		assertNotNull(genId2);
 		assertEquals(idgenId2.id);
 	}
 
 	public void testAllTypes() throws Exception {
 		Dao<AllTypesIntegerallDao = createDao(AllTypes.classtrue);
 		AllTypes allTypes = new AllTypes();
 		String stringVal = "some string";
 		boolean boolVal = true;
 		// we have to round this because the db may not be storing millis
 		long millis = (System.currentTimeMillis() / 1000) * 1000;
		Date dateVal = new Date(millis);
		Date dateLongVal = new Date(millis);
		Date dateStringVal = new Date(millis);