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.Date;
  import java.util.List;
  
  import org.junit.Before;
  import org.junit.Test;
  
  
  public class JdbcBaseDaoImplTest extends BaseOrmLiteTest {
  
  	private final boolean CLOSE_IS_NOOP = false;
  	private final boolean UPDATE_ROWS_RETURNS_ONE = false;
  
  	@Before
  	public void before() throws Exception {
  		super.before();
  		 = createDao(Foo.classtrue);
  	}
  
  	/* ======================================================================================== */
  
  	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;
  	private 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 static DateFormat defaultDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSSSSS");
  	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";
  
  	// needs to be protected for test base classes
  	protected Dao<FooIntegerfooDao;
  
  	@Test
  	public void testCreateDaoStatic() throws Exception {
  		Dao<FooIntegerfooDao = BaseDaoImpl.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);
  	}
  
  	@Test
  	public void testCreateUpdateDelete() throws Exception {
  		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
 		assertTrue(foo1.id != 0);
 		assertEquals(s1foo1.stuff);
 
 		// now we query for foo from the database to make sure it was persisted right
 		Foo foo2 = .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
 
 		// now we get it from the db again to make sure it was updated correctly
 		Foo foo3 = .queryForId(foo1.id);
 		assertEquals(s2foo3.stuff);
 
 	}
 
 	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 (Exception e) {
 			// expected
 		}
 	}
 
 	public void testIterateRemove() throws Exception {
 		List<FooacctList = .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";
 		.create(foo1);
 		.create(foo2);
 		.create(foo3);
 
 		assertTrue(foo1.id != foo2.id);
 		assertTrue(foo1.id != foo3.id);
 		assertTrue(foo2.id != foo3.id);
 
 		assertEquals(foo1.queryForId(foo1.id));
 		assertEquals(foo2.queryForId(foo2.id));
 		assertEquals(foo3.queryForId(foo3.id));
 
 		acctList = .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 = .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 {
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		assertEquals(0, foo1.id);
 		assertTrue(foo1.id != 0);
 	}
 
 	public void testGeneratedIdNotNullField() throws Exception {
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		assertEquals(0, foo1.id);
 		assertTrue(foo1.id != 0);
 	}
 
 	public void testObjectToString() throws Exception {
 		String stuff = "foo123231";
 		Foo foo1 = new Foo();
 		foo1.stuff = stuff;
 		String objStr = .objectToString(foo1);
 		assertTrue(objStr.contains(Integer.toString(foo1.id)));
 		assertTrue(objStr.contains(stuff));
 	}
 
 	public void testCreateNull() throws Exception {
 	}
 
 	public void testUpdateNull() throws Exception {
 		assertEquals(0, .update((Foonull));
 	}
 
 	public void testUpdateIdNull() throws Exception {
 		assertEquals(0, .updateId(nullnull));
 	}
 
 	public void testDeleteNull() throws Exception {
 		assertEquals(0, .delete((Foonull));
 	}
 
 	public void testCloseInIterator() throws Exception {
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		.create(foo1);
 		Iterator<Fooiterator = .iterator();
 		try {
 			while (iterator.hasNext()) {
 				iterator.next();
 			}
 			if (!) {
 				fail("expected exception");
 			}
 		} catch (IllegalStateException e) {
 			// expected
 		}
 	}
 
 	public void testCloseIteratorFirst() throws Exception {
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		.create(foo1);
 		try {
 			fail("expected exception");
 		} catch (IllegalStateException e) {
 			// expected
 		}
 	}
 
 	public void testCloseIteratorBeforeNext() throws Exception {
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		.create(foo1);
 		Iterator<Fooiterator = .iterator();
 		try {
 			while (iterator.hasNext()) {
 				iterator.next();
 			}
 			if (!) {
 				fail("expected exception");
 			}
 		} catch (IllegalStateException e) {
 			// expected
 		}
 	}
 
 	public void testCloseIteratorBeforeRemove() throws Exception {
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		.create(foo1);
 		Iterator<Fooiterator = .iterator();
 		try {
 			while (iterator.hasNext()) {
 				iterator.next();
 				iterator.remove();
 			}
 			fail("expected exception");
 		} catch (Exception e) {
 			// expected
 		}
 	}
 
 	public void testNoNextBeforeRemove() throws Exception {
 		Foo foo1 = new Foo();
 		foo1.stuff = "s1";
 		.create(foo1);
 		Iterator<Fooiterator = .iterator();
 		try {
 			iterator.remove();
 			fail("expected exception");
 		} catch (IllegalStateException e) {
 			// expected
 		}
 	}
 
 	public void testIteratePageSize() throws Exception {
 		for (int i = 0; i < 1000; i++) {
 			Foo foo = new Foo();
 			foo.stuff = Integer.toString(i);
 		}
 		Iterator<Fooiterator = .iterator();
 		while (iterator.hasNext()) {
 			iterator.next();
 			iterator.remove();
 		}
 	}
 
 	public void testDeleteObjects() throws Exception {
 		List<FoofooList = new ArrayList<Foo>();
 		for (int i = 0; i < 100; i++) {
 			Foo foo = new Foo();
 			foo.stuff = Integer.toString(i);
 			fooList.add(foo);
 		}
 
 		int deleted = .delete(fooList);
 			assertEquals(1, deleted);
 		} else {
 			assertEquals(fooList.size(), deleted);
 		}
 	}
 
 	public void testDeleteObjectsNone() throws Exception {
 		List<FoofooList = new ArrayList<Foo>();
 		assertEquals(fooList.size(), .delete(fooList));
 	}
 
 	public void testDeleteIds() throws Exception {
 		List<IntegerfooIdList = new ArrayList<Integer>();
 		for (int i = 0; i < 100; i++) {
 			Foo foo = new Foo();
 			fooIdList.add(foo.id);
 		}
 
 		int deleted = .deleteIds(fooIdList);
 			assertEquals(1, deleted);
 		} else {
 			assertEquals(fooIdList.size(), deleted);
 		}
 	}
 
 	public void testDeleteIdsNone() throws Exception {
 		List<IntegerfooIdList = new ArrayList<Integer>();
 		assertEquals(fooIdList.size(), .deleteIds(fooIdList));
 	}
 
 	public void testDeletePreparedStmtIn() throws Exception {
 		List<IntegerfooIdList = new ArrayList<Integer>();
 		for (int i = 0; i < 100; i++) {
 			Foo foo = new Foo();
 			fooIdList.add(foo.id);
 		}
 
 		DeleteBuilder<FooIntegerstmtBuilder = .deleteBuilder();
 		stmtBuilder.where().in(.fooIdList);
 
 		int deleted = .delete(stmtBuilder.prepare());
 			assertEquals(1, deleted);
 		} else {
 			assertEquals(fooIdList.size(), deleted);
 		}
 	}
 
 	public void testDeleteAllPreparedStmt() throws Exception {
 		int fooN = 100;
 		for (int i = 0; i < fooNi++) {
 			Foo foo = new Foo();
 		}
 
 		DeleteBuilder<FooIntegerstmtBuilder = .deleteBuilder();
 
 		int deleted = .delete(stmtBuilder.prepare());
 			assertEquals(1, deleted);
 		} else {
 			assertEquals(fooNdeleted);
 		}
 	}
 
 	public void testHasNextAfterDone() throws Exception {
 		Iterator<Fooiterator = .iterator();
 		while (iterator.hasNext()) {
 		}
 		assertFalse(iterator.hasNext());
 	}
 
 	public void testNextWithoutHasNext() throws Exception {
 		Iterator<Fooiterator = .iterator();
 		try {
 			iterator.next();
 			fail("expected exception");
 		} catch (Exception e) {
 			// expected
 		}
 	}
 
 	public void testRemoveAfterDone() throws Exception {
 		Iterator<Fooiterator = .iterator();
 		assertFalse(iterator.hasNext());
 		try {
 			iterator.remove();
 			fail("expected exception");
 		} catch (IllegalStateException e) {
 			// expected
 		}
 	}
 
 	public void testIteratorNoResults() throws Exception {
 		Iterator<Fooiterator = .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 {
 		String stuff1 = "just-id-refresh-1";
 		Foo foo1 = new Foo();
 		foo1.stuff = stuff1;
 		int id = foo1.id;
 		Foo foo2 = .queryForId(id);
 		assertEquals(idfoo2.id);
 		assertEquals(stuff1foo2.stuff);
 		String stuff2 = "just-id-refresh-2";
 		foo2.stuff = stuff2;
 
 		// change the id in the db
 		Foo foo3 = .queryForId(id);
 		assertEquals(idfoo3.id);
 		assertEquals(stuff2foo3.stuff);
 
 		assertEquals(stuff1foo1.stuff);
 		assertEquals(stuff2foo1.stuff);
 	}
 
 	public void testSpringConstruction() throws Exception {
 		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<ForeignIntegerforeignDao = createDao(Foreign.classtrue);
 
 		Foreign foreign = new Foreign();
 		String stuff1 = "stuff1";
 		foreign.stuff = 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.stuff);
 		assertEquals(1, foreignDao.refresh(wrapper2.foreign));
 		// now it should be true
 		assertTrue(foreignDao.objectsEqual(foreignwrapper2.foreign));
 		assertEquals(stuff1wrapper2.foreign.stuff);
 
 		// create a new foreign
 		foreign = new Foreign();
 		String stuff2 = "stuff2";
 		foreign.stuff = 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.stuff);
 		assertEquals(1, foreignDao.refresh(wrapper2.foreign));
 		// now it should be true
 		assertTrue(foreignDao.objectsEqual(foreignwrapper2.foreign));
 		assertEquals(stuff2wrapper2.foreign.stuff);
 	}
 
 	public void testForeignRefreshNoChange() throws Exception {
 		Dao<ForeignWrapperIntegerwrapperDao = createDao(ForeignWrapper.classtrue);
 		Dao<ForeignIntegerforeignDao = createDao(Foreign.classtrue);
 
 		Foreign foreign = new Foreign();
 		String stuff1 = "stuff1";
 		foreign.stuff = 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));
 		Foreign foreign2 = wrapper2.foreign;
 		assertEquals(stuff1foreign2.stuff);
 
 		assertEquals(1, wrapperDao.refresh(wrapper2));
 		assertSame(foreign2wrapper2.foreign);
 		assertEquals(stuff1wrapper2.foreign.stuff);
 
 		// now, in the background, we change the foreign
 		ForeignWrapper wrapper3 = wrapperDao.queryForId(wrapper.id);
 		Foreign foreign3 = new Foreign();
 		String stuff3 = "stuff3";
 		foreign3.stuff = 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.stuff);
 	}
 
 	public void testMultipleForeignWrapper() throws Exception {
 		Dao<MultipleForeignWrapperIntegermultipleWrapperDao = createDao(MultipleForeignWrapper.classtrue);
 		Dao<ForeignWrapperIntegerwrapperDao = createDao(ForeignWrapper.classtrue);
 		Dao<ForeignIntegerforeignDao = createDao(Foreign.classtrue);
 
 		Foreign foreign = new Foreign();
 		String stuff1 = "stuff1";
 		foreign.stuff = 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.stuff);
 		assertEquals(wrapper.idmultiWrapper2.foreignWrapper.id);
 		assertNull(multiWrapper2.foreignWrapper.foreign);
 
 		assertEquals(1, foreignDao.refresh(multiWrapper2.foreign));
 		assertEquals(stuff1multiWrapper2.foreign.stuff);
 		assertNull(multiWrapper2.foreignWrapper.foreign);
 
 		assertEquals(1, wrapperDao.refresh(multiWrapper2.foreignWrapper));
 		assertEquals(foreign.idmultiWrapper2.foreignWrapper.foreign.id);
 		assertNull(multiWrapper2.foreignWrapper.foreign.stuff);
 
 		assertEquals(1, foreignDao.refresh(multiWrapper2.foreignWrapper.foreign));
 		assertEquals(stuff1multiWrapper2.foreignWrapper.foreign.stuff);
 	}
 
 	public void testRefreshNull() throws Exception {
 		// this should be a noop
 	}
 
 	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,
 				falsenullfalsenullfalsenullfalse));
 		fieldConfigs.add(new DatabaseFieldConfig("stuff""stuffy".null, 0, falsefalsefalse,
 				nullfalsenullfalsenullfalsenullfalse));
 		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>();
 		noAnnotationsFieldConfigs.add(new DatabaseFieldConfig("id""idthingie".null, 0, false,
 				falsetruenullfalsenullfalsenullfalsenullfalse));
 		noAnnotationsFieldConfigs.add(new DatabaseFieldConfig("stuff""stuffy".null, 0, false,
 				falsefalsenullfalsenullfalsenullfalsenullfalse));
 		DatabaseTableConfig<NoAnnonoAnnotationsTableConfig =
 				new DatabaseTableConfig<NoAnno>(NoAnno.classnoAnnotationsFieldConfigs);
 		Dao<NoAnnoIntegernoAnnotaionDao = createDao(noAnnotationsTableConfigtrue);
 		NoAnno noa = new NoAnno();
 		String stuff = "qpoqwpjoqwp12";
 		noa.stuff = stuff;
 		assertEquals(1, noAnnotaionDao.create(noa));
 		assertNotNull(noAnnotaionDao.queryForId(noa.id));
 
 		List<DatabaseFieldConfignoAnnotationsForiegnFieldConfigs = new ArrayList<DatabaseFieldConfig>();
 		noAnnotationsForiegnFieldConfigs.add(new DatabaseFieldConfig("id""anotherid".null, 0,
 				falsefalsetruenullfalsenullfalsenullfalsenullfalse));
 		noAnnotationsForiegnFieldConfigs.add(new DatabaseFieldConfig("foreign""foreignThingie".,
 				null, 0, falsefalsefalsenulltruenoAnnotationsTableConfigfalsenullfalsenullfalse));
 		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, noAnnotaionDao.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 (Exception 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 (Exception 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<AllTypesObjectallDao = 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);
 		byte byteVal = 117;
 		short shortVal = 15217;
 		int intVal = 1023213;
 		long longVal = 1231231231231L;
 		float floatVal = 123.13F;
 		double doubleVal = 1413312.1231233;
 		OurEnum ourEnum = .;
 		allTypes.stringField = stringVal;
 		allTypes.booleanField = boolVal;
 		allTypes.dateField = dateVal;
 		allTypes.dateLongField = dateLongVal;
 		allTypes.dateStringField = dateStringVal;
 		allTypes.byteField = byteVal;
 		allTypes.shortField = shortVal;
 		allTypes.intField = intVal;
 		allTypes.longField = longVal;
 		allTypes.floatField = floatVal;
 		allTypes.doubleField = doubleVal;
 		allTypes.ourEnum = ourEnum;
 		String stuff = "ewpjowpjogrjpogrjp";
 		SerialField obj = new SerialField();
 		obj.stuff = stuff;
 		allTypes.objectField = obj;
 		assertEquals(1, allDao.create(allTypes));
 		List<AllTypesallTypesList = allDao.queryForAll();
 		assertEquals(1, allTypesList.size());
 		assertTrue(allDao.objectsEqual(allTypesallTypesList.get(0)));
 	}
 
 	public void testAllTypesDefault() throws Exception {
 		Dao<AllTypesObjectallDao = createDao(AllTypes.classtrue);
 		AllTypes allTypes = new AllTypes();
 		assertEquals(1, allDao.create(allTypes));
 		List<AllTypesallTypesList = allDao.queryForAll();
 		assertEquals(1, allTypesList.size());
 		assertTrue(allDao.objectsEqual(allTypesallTypesList.get(0)));
 	}
 
 	public void testNumberTypes() throws Exception {
 		Dao<NumberTypesObjectnumberDao = createDao(NumberTypes.classtrue);
 
 		NumberTypes numberMins = new NumberTypes();
 		numberMins.byteField = .;
 		numberMins.shortField = .;
 		numberMins.intField = .;
 		numberMins.longField = .;
 		numberMins.floatField = -1.0e+37F;
 		numberMins.doubleField = -1.0e+307;
 		assertEquals(1, numberDao.create(numberMins));
 
 		NumberTypes numberMins2 = new NumberTypes();
 		numberMins2.byteField = .;
 		numberMins2.shortField = .;
 		numberMins2.intField = .;
 		numberMins2.longField = .;
 		numberMins2.floatField = 1.0e-37F;
 		// derby couldn't take 1.0e-307 for some reason
 		numberMins2.doubleField = 1.0e-306;
 		assertEquals(1, numberDao.create(numberMins2));
 
 		NumberTypes numberMaxs = new NumberTypes();
 		numberMaxs.byteField = .;
 		numberMaxs.shortField = .;
 		numberMaxs.intField = .;
 		numberMaxs.longField = .;
 		numberMaxs.floatField = 1.0e+37F;
 		numberMaxs.doubleField = 1.0e+307;
 		assertEquals(1, numberDao.create(numberMaxs));
 
 		List<NumberTypesallTypesList = numberDao.queryForAll();
 		assertEquals(3, allTypesList.size());
 		assertTrue(numberDao.objectsEqual(numberMinsallTypesList.get(0)));
 		assertTrue(numberDao.objectsEqual(numberMins2allTypesList.get(1)));
 		assertTrue(numberDao.objectsEqual(numberMaxsallTypesList.get(2)));
 	}
 
 	public void testStringWidthTooLong() throws Exception {
 			return;
 		}
 		Dao<StringWidthObjectstringWidthDao = createDao(StringWidth.classtrue);
 		StringWidth stringWidth = new StringWidth();
 		StringBuilder sb = new StringBuilder();
 		for (int i = 0; i <  + 1; i++) {
 			sb.append("c");
 		}
 		String string = sb.toString();
		stringWidth.stringField = string;
		try {