/** Asynchronous version of {@link AbstractDaoSession#callInTx(Callable)}. */ public AsyncOperation callInTx(Callable<?> callable) { return callInTx(callable, 0); }
/** Asynchronous version of {@link AbstractDao#count()}. */ public AsyncOperation count(Class<?> entityClass) { return count(entityClass, 0); }
/** Asynchronous version of {@link AbstractDao#insert(Object)}. */ public AsyncOperation insert(Object entity) { return insert(entity, 0); }
public void testMergeInsertAndUpdate() { SimpleEntity entity = new SimpleEntity(); entity.setId(42l); entity.setSimpleString("heho"); SimpleEntity entity2 = new SimpleEntity(); entity2.setId(42l); entity2.setSimpleString("updated"); AsyncOperation op1 = asyncSession.insert(entity, AsyncOperation.FLAG_MERGE_TX); AsyncOperation op2 = asyncSession.update(entity2, AsyncOperation.FLAG_MERGE_TX); assertWaitForCompletion1Sec(); daoSession.clear(); SimpleEntity entity3 = daoSession.load(SimpleEntity.class, 42l); assertNotNull(entity3); assertEquals(entity2.getSimpleString(), entity3.getSimpleString()); assertEquals(2, op1.getMergedOperationsCount()); assertEquals(2, op2.getMergedOperationsCount()); }
public void testAsyncOperationWait() { AsyncOperation operation = asyncSession.insert(new SimpleEntity()); asyncSession.waitForCompletion(); assertSingleOperationCompleted(operation); }
public void testListenerMainThread() throws InterruptedException { AsyncOperationListener listener = new AsyncOperationListener() { @Override public synchronized void onAsyncOperationCompleted(AsyncOperation operation) { assertEquals(Looper.getMainLooper(), Looper.myLooper()); testListenerMainThread_done = true; notifyAll(); } }; asyncSession.setListenerMainThread(listener); asyncSession.insert(new SimpleEntity()); assertWaitForCompletion1Sec(); while (!testListenerMainThread_done) { synchronized (listener) { listener.wait(1000); } } }
/** Asynchronous version of {@link AbstractDao#load(Object)}. */ public AsyncOperation load(Class<?> entityClass, Object key) { return load(entityClass, key, 0); }
/** Asynchronous version of {@link AbstractDao#insertOrReplace(Object)}. */ public AsyncOperation insertOrReplace(Object entity) { return insertOrReplace(entity, 0); }
/** Asynchronous version of {@link AbstractDao#update(Object)}. */ public AsyncOperation update(Object entity) { return update(entity, 0); }
/** Asynchronous version of {@link AbstractDaoSession#runInTx(Runnable)}. */ public AsyncOperation runInTx(Runnable runnable) { return runInTx(runnable, 0); }
public void testAsyncExceptionCreator() { SimpleEntity entity = new SimpleEntity(); daoSession.insert(entity); AsyncOperation operation = asyncSession.insert(entity); assertWaitForCompletion1Sec(); assertNull(operation.getCreatorStacktrace()); operation = asyncSession.insert(entity, AsyncOperation.FLAG_TRACK_CREATOR_STACKTRACE); assertWaitForCompletion1Sec(); assertNotNull(operation.getCreatorStacktrace()); asyncSession.setSessionFlags(AsyncOperation.FLAG_TRACK_CREATOR_STACKTRACE); operation = asyncSession.insert(entity); assertWaitForCompletion1Sec(); assertNotNull(operation.getCreatorStacktrace()); StackTraceElement[] stack = operation.getCreatorStacktrace().getStackTrace(); boolean found = false; for (StackTraceElement stackTraceElement : stack) { found |= stackTraceElement.getClassName().equals(getClass().getName()); } assertTrue(found); }
/** * Creates a new {@link AsyncSession} to issue asynchronous entity operations. See {@link AsyncSession} for details. */ public AsyncSession startAsyncSession() { return new AsyncSession(this); }
/** Asynchronous version of {@link AbstractDao#delete(Object)}. */ public AsyncOperation delete(Object entity) { return delete(entity, 0); }
/** Asynchronous version of {@link AbstractDao#deleteAll()}. */ public <E> AsyncOperation deleteAll(Class<E> entityClass) { return deleteAll(entityClass, 0); }
public void testAsyncOperationWaitMillis() { AsyncOperation operation = asyncSession.insert(new SimpleEntity()); assertTrue(asyncSession.waitForCompletion(1000)); assertSingleOperationCompleted(operation); }
public void testOperationGetResult() { SimpleEntity entity = new SimpleEntity(); entity.setSimpleString("heho"); daoSession.insert(entity); daoSession.clear(); AsyncOperation operation = asyncSession.load(SimpleEntity.class, entity.getId()); SimpleEntity result = (SimpleEntity) operation.getResult(); assertTrue(operation.isCompleted()); assertTrue(operation.isCompletedSucessfully()); assertNotNull(result); assertNotSame(entity, result); assertEquals(entity.getId(), result.getId()); assertEquals(entity.getSimpleString(), result.getSimpleString()); }
public static <T extends Object> T createOrReplace(T entity){ if (entity==null) return null; asyncSession.insertOrReplace(entity); return entity; }
public void testAsyncUpdate() { SimpleEntity entity = new SimpleEntity(); entity.setSimpleString("heho"); daoSession.insert(entity); entity.setSimpleString("updated"); AsyncOperation operation = asyncSession.update(entity); assertWaitForCompletion1Sec(); daoSession.clear(); SimpleEntity entity2 = daoSession.load(SimpleEntity.class, entity.getId()); assertNotNull(entity2); assertEquals("updated", entity2.getSimpleString()); assertFalse(operation.isFailed()); assertSingleOperationCompleted(operation); }
public void testAsyncRunInTx() { AsyncOperation operation = asyncSession.runInTx(new Runnable() { @Override public void run() { txThread = Thread.currentThread(); } }); assertWaitForCompletion1Sec(); assertSingleOperationCompleted(operation); assertNotNull(txThread); assertFalse(Thread.currentThread().equals(txThread)); }
/** * Creates a new {@link AsyncSession} to issue asynchronous entity operations. See {@link AsyncSession} for details. */ public AsyncSession startAsyncSession() { return new AsyncSession(this); }