@Test
public void testTakeSuspendableSlot() {
waitTillDone();
ThreadHandler th = ThreadHandler.getInstance();
th.scheduleTask(new SimpleSuspendableTask(new SuspendableTestThread(300)));
for (int i = 0; i < d_numCores - 1; ++i)
th.scheduleTask(new SimpleSuspendableTask(new NonSuspendableTestThread(300)));
SimpleTask newTask = new SimpleSuspendableTask(new SuspendableTestThread(300));
th.scheduleTask(newTask);
sleepLongEnough();
assertTrue(th.getRunningTasks().contains(newTask));
waitTillDone();
for (int i = 0; i < d_numCores - 1; ++i)
th.scheduleTask(new SimpleSuspendableTask(new NonSuspendableTestThread(300)));
th.scheduleTask(new SimpleSuspendableTask(new SuspendableTestThread(300)));
newTask = new SimpleSuspendableTask(new SuspendableTestThread(300));
th.scheduleTask(newTask);
sleepLongEnough();
assertTrue(th.getRunningTasks().contains(newTask));
waitTillDone();
}
@Test
public void testHighLoad() {
final int NUMTHREADS = 100;
LinkedList<SimpleTask> runnables = new LinkedList<SimpleTask>();
ThreadHandler th = ThreadHandler.getInstance();
ArrayList<SimpleTask> threadList = new ArrayList<SimpleTask>(NUMTHREADS);
for (int i = 0; i < NUMTHREADS; ++i) {
SimpleTask mod =
new SimpleSuspendableTask(new SuspendableTestThread((int) (Math.random() * 100)));
threadList.add(mod);
runnables.add(mod);
if ((Math.random() > 0.75) || (i == (NUMTHREADS - 1))) {
th.scheduleTasks(runnables);
runnables.clear();
}
sleep((int) (Math.random() * 50));
assertTrue(Runtime.getRuntime().availableProcessors() >= th.d_runningTasks.size());
}
assertTrue(Runtime.getRuntime().availableProcessors() >= th.d_runningTasks.size());
waitTillDone();
for (SimpleTask mod : threadList) {
assertTrue(mod.isFinished());
}
}
//
// main thread will wait, until return or user cancel, or it will block the UI, if no network
// responsing
// new a thread to request the token
// and let user can cancel the process
//
private synchronized void startThread() {
HandlerThread thread = new HandlerThread("LoginThread", Process.THREAD_PRIORITY_BACKGROUND);
thread.start();
mServiceLooper = thread.getLooper();
mHandler = new ThreadHandler(mServiceLooper);
Message msd = mHandler.obtainMessage(AUTH_LOGIN);
mHandler.sendMessageDelayed(msd, 1 * 1000);
}
void launchLoginActivity() {
try {
setTitle(R.string.facebook_request_token_title);
facebook_info.setText(R.string.facebook_request_token_title);
isInProcess = true;
token = loghelper.getDesktopApp().requestToken();
isInProcess = false;
getToken = true;
loginURL = loghelper.getDesktopApp().getLoginUrl(token);
if (getToken == false) {
Toast.makeText(
FacebookLoginActivity.this,
R.string.facebook_get_accesstoken_failed,
Toast.LENGTH_LONG)
.show();
FacebookLoginActivity.this.setTitle(R.string.sns_network_unavailable);
facebook_info.setText(R.string.facebook_login_failed_message);
} else {
Log.d(TAG, "after get token=" + token);
mHandler.obtainMessage(QUIT_THREAD).sendToTarget();
Intent intent = new Intent(FacebookLoginActivity.this, FacebookLoginWebViewActivity.class);
intent.putExtra("facebook_loginURL", loginURL);
startActivityForResult(intent, LOGIN_WEBVIEW);
}
} catch (FacebookException ne) {
isInProcess = false;
Log.d(TAG, "fail to request the token=" + ne.getMessage());
sendMessageToService(false);
count--;
if (count >= 0) {
Log.d(TAG, "get token again");
Message msd = mHandler.obtainMessage(LOAD_LOGIN_PAGE);
mHandler.sendMessageDelayed(msd, 5 * 1000);
}
}
if (getToken == false) {
handler.obtainMessage(NETWORK_UNAVAL).sendToTarget();
}
Log.d(TAG, "continue");
if (getToken == true || count <= 0) {
mHandler.obtainMessage(QUIT_THREAD).sendToTarget();
}
}
@Test
public void testScheduleCompositeTask() {
waitTillDone();
ThreadHandler threadHandler = ThreadHandler.getInstance();
SomeCompositeTask task = new SomeCompositeTask();
threadHandler.scheduleTask(task);
sleepLongEnough();
assertEquals(Collections.singletonList(task.d_first), threadHandler.getRunningTasks());
assertEquals(Collections.singletonList(task), threadHandler.getQueuedTaskList());
// wait for first task to finish and subsequent tasks to be enqueued
waitTillDone(task.d_first);
sleepLongEnough();
List<Task> expected = new ArrayList<Task>();
expected.add(task.d_middle1);
if (d_numCores >= 2) {
expected.add(task.d_middle2);
}
assertEquals(expected, threadHandler.getRunningTasks());
// wait for last task to be finished and its finishing to be detected
waitTillDone(task.d_last);
sleepLongEnough();
assertTrue(task.d_last.isFinished());
assertTrue(task.isFinished());
assertEquals(Collections.<Task>emptyList(), threadHandler.getQueuedTaskList());
}
@Test
public void testRemoveWaitingCompositeTask() {
waitTillDone();
ThreadHandler th = ThreadHandler.getInstance();
List<Task> tasks = new ArrayList<Task>();
for (int i = 0; i < d_numCores; ++i) {
tasks.add(new SimpleSuspendableTask(new SuspendableTestThread(300)));
}
SomeCompositeTask composite = new SomeCompositeTask();
tasks.add(composite);
th.scheduleTasks(tasks);
sleepLongEnough();
th.abortTask(composite);
sleepLongEnough();
}
@Test
public void testQueueingOrder() {
LinkedList<SimpleTask> ToDo1 = new LinkedList<SimpleTask>();
LinkedList<SimpleTask> ToDo2 = new LinkedList<SimpleTask>();
for (int i = 0; i < d_numCores; ++i) {
ToDo1.add(new SimpleSuspendableTask(new SuspendableTestThread(400)));
if (i < d_numCores - 1) {
ToDo2.add(new SimpleSuspendableTask(new SuspendableTestThread(400)));
}
}
ThreadHandler th = ThreadHandler.getInstance();
th.scheduleTasks(ToDo1); // fills the available cores
th.scheduleTasks(ToDo2); // should push back every task except ToDo1[0].
sleepLongEnough();
List<SimpleTask> expected = new ArrayList<SimpleTask>(ToDo2);
expected.add(ToDo1.get(0));
assertEquals(expected, th.getRunningTasks());
}
@Override
protected void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestory");
// quit thread
if (mHandler != null) {
if (mServiceLooper != null) {
mHandler.obtainMessage(QUIT_THREAD).sendToTarget();
}
}
}
@Test
public void testReprioritiseDontTouchNonSuspendable() {
LinkedList<SimpleTask> ToDo1 = new LinkedList<SimpleTask>();
LinkedList<SimpleTask> ToDo2 = new LinkedList<SimpleTask>();
for (int i = 0; i < d_numCores - 1; ++i) {
ToDo1.add(new SimpleSuspendableTask(new SuspendableTestThread(600)));
ToDo2.add(new SimpleSuspendableTask(new SuspendableTestThread(600)));
}
ToDo1.add(new SimpleSuspendableTask(new NonSuspendableTestThread(600)));
ToDo2.add(new SimpleSuspendableTask(new SuspendableTestThread(400)));
ThreadHandler th = ThreadHandler.getInstance();
th.scheduleTasks(ToDo1);
sleepLongEnough();
assertEquals(th.getRunningTasks(), ToDo1);
LinkedList<SimpleTask> expected =
new LinkedList<SimpleTask>(ToDo2.subList(0, ToDo2.size() - 1));
expected.addFirst(ToDo1.getLast());
th.scheduleTasks(ToDo2);
sleepLongEnough();
assertEquals(expected, th.getRunningTasks());
}
@Test
public void testRemoveCompositeTaskWithDuplicateTask() {
ThreadHandler threadHandler = ThreadHandler.getInstance();
SomeCompositeTask task = new SomeCompositeTask();
SimpleTask duplicate = task.d_first;
threadHandler.scheduleTask(duplicate);
threadHandler.scheduleTask(task);
sleepLongEnough();
List<Task> expected = new ArrayList<Task>();
expected.add(task);
expected.add(duplicate);
assertEquals(Collections.singletonList(duplicate), threadHandler.getRunningTasks());
assertEquals(expected, threadHandler.getQueuedTaskList());
threadHandler.abortTask(task);
sleepLongEnough();
assertFalse(duplicate.isFinished());
expected.remove(task);
assertEquals(expected, threadHandler.getQueuedTaskList());
assertEquals(Collections.singletonList(duplicate), threadHandler.getRunningTasks());
}
@Test
public void testRemoveCantRemoveUnsuspendableRunningTask() {
waitTillDone();
ThreadHandler th = ThreadHandler.getInstance();
SimpleSuspendableTask t = new SimpleSuspendableTask(new NonSuspendableTestThread(1000));
th.scheduleTask(t);
sleepLongEnough();
assertEquals(1, th.getRunningThreads());
assertFalse(th.abortTask(t));
sleepLongEnough();
assertEquals(1, th.getRunningThreads());
}
@Test
public void testClearRemovesWaitingTasks() {
waitTillDone();
ThreadHandler th = ThreadHandler.getInstance();
List<SimpleTask> runthreads = new ArrayList<SimpleTask>();
for (int i = 0; i < d_numCores + 2; ++i) // 2 threads in waiting list.
runthreads.add(new SimpleSuspendableTask(new SuspendableTestThread(100)));
th.scheduleTasks(runthreads);
assertEquals(d_numCores + 2, th.getQueuedTasks());
th.clear();
assertEquals(0, th.getQueuedTasks());
}
@Test
public void testRemoveSuspendableRunningTask() {
waitTillDone();
ThreadHandler th = ThreadHandler.getInstance();
SimpleTask task = new SimpleSuspendableTask(new SuspendableTestThread(10000));
th.scheduleTask(task);
sleepLongEnough();
assertEquals(1, th.getRunningThreads());
th.abortTask(task);
sleepLongEnough();
assertEquals(0, th.getRunningThreads());
assertFalse(task.isFinished());
assertTrue(task.isAborted());
assertFalse(task.isSuspended());
}
@Test
public void testClearCantRemoveUnsuspendableRunningTasks() {
waitTillDone();
ThreadHandler th = ThreadHandler.getInstance();
List<SimpleTask> runthreads = new ArrayList<SimpleTask>();
for (int i = 0; i < d_numCores; ++i) // numcore threads running.
runthreads.add(new SimpleSuspendableTask(new NonSuspendableTestThread(600)));
th.scheduleTasks(runthreads);
sleepLongEnough();
assertEquals(d_numCores, th.getRunningThreads());
th.clear();
sleepLongEnough();
assertEquals(d_numCores, th.getRunningThreads());
}
@Test
public void testRemoveWaitingSimpleTask() {
waitTillDone();
ThreadHandler th = ThreadHandler.getInstance();
List<SimpleTask> runthreads = new ArrayList<SimpleTask>();
SimpleTask t = new SimpleSuspendableTask(new SuspendableTestThread(100));
for (int i = 0; i < d_numCores + 1; ++i) {
runthreads.add(new SimpleSuspendableTask(new SuspendableTestThread(100)));
}
runthreads.add(t); // 2 threads in waiting list.
th.scheduleTasks(runthreads);
assertEquals(d_numCores + 2, th.getQueuedTasks());
th.abortTask(t);
assertEquals(d_numCores + 1, th.getQueuedTasks());
waitTillDone();
assertFalse(t.isFinished());
}
@Test
public void testRemoveCompositeTask() {
waitTillDone();
ThreadHandler th = ThreadHandler.getInstance();
SomeCompositeTask task = new SomeCompositeTask();
th.scheduleTask(task);
// wait for first task to finish and subsequent tasks to be enqueued
waitTillDone(task.d_first);
sleepLongEnough();
th.abortTask(task);
sleepLongEnough();
assertTrue(task.d_first.isFinished());
assertTrue(task.d_middle1.isAborted());
if (d_numCores > 1) {
assertTrue(task.d_middle2.isAborted());
}
assertEquals(0, th.getRunningTasks().size());
assertEquals(0, th.getQueuedTaskList().size());
}
@Before
public void setUp() {
ThreadHandler.getInstance().clear();
d_numCores = Runtime.getRuntime().availableProcessors();
}
@Test
public void testReprioritise() {
LinkedList<SimpleTask> ToDo1 = new LinkedList<SimpleTask>();
final int NUMMODELS = d_numCores + 2;
for (int i = 0; i < NUMMODELS; ++i) {
ToDo1.add(new SimpleSuspendableTask(new SuspendableTestThread((i + 4) * 400)));
}
ThreadHandler th = ThreadHandler.getInstance();
th.scheduleTasks(ToDo1);
List<SimpleTask> nCoresHeadList = ToDo1.subList(0, d_numCores);
List<SimpleTask> nCoresHeadListComplement =
ToDo1.subList(d_numCores, d_numCores + (NUMMODELS - d_numCores));
sleepLongEnough();
assertTrue(th.getRunningTasks().containsAll(nCoresHeadList));
assertTrue(th.getQueuedTaskList().containsAll(ToDo1));
// Note: NOP; rescheduling already-running tasks should not change anything
th.scheduleTasks(nCoresHeadList);
sleepLongEnough();
assertTrue(th.getRunningTasks().containsAll(nCoresHeadList));
assertTrue(th.getQueuedTaskList().containsAll(ToDo1));
// reprioritise scheduled tasks by re-adding them; should displace running tasks
th.scheduleTasks(nCoresHeadListComplement);
sleepLongEnough();
assertTrue(th.getRunningTasks().containsAll(nCoresHeadListComplement));
assertTrue(th.getRunningTasks().containsAll(nCoresHeadList.subList(0, d_numCores - 2)));
assertTrue(th.getQueuedTaskList().containsAll(ToDo1));
}
void auth_login() {
isInProcess = true;
setButtonEnable(false);
Log.d(TAG, "reconstrcut the facebook session");
final FacebookSession tmps;
boolean persm = false;
try {
setHint(getString(R.string.verify_account_hint));
tmps = loghelper.getDesktopApp().AuthLoginNoSession(loghelper.getEmail(), loghelper.getPwd());
} catch (FacebookException e) {
Log.e(TAG, "fail to get facebook session=" + e.getMessage());
handler.post(
new Runnable() {
public void run() {
facebook_info.setText(R.string.facebook_fail_to_get_session);
// FacebookLoginActivity.this.setResult(200);
// sendMessageToService(false);
// quitLooperAndFinish();
}
});
mHandler.obtainMessage(QUIT_THREAD).sendToTarget();
isInProcess = false;
setButtonEnable(true);
return;
}
try {
persm =
tmps.AuthLogin(
tmps.getSessionKey(),
FacebookLoginHelper.SECRET_KEY,
loghelper.getEmail(),
loghelper.getPwd());
} catch (FacebookException e) {
Log.e(TAG, "Fail to get permanant session, ignore this step.");
}
setHint(getString(R.string.verify_account_suc_hint));
// get login info in background
// save into database
String Sessionkey = tmps.getSessionKey();
String secretKey = tmps.getSecretKey();
long userId = tmps.getLogerInUserID();
loghelper.recordTmpSession(Sessionkey, secretKey, userId);
SocialORM orm = SocialORM.instance(FacebookLoginActivity.this);
if (true == persm) {
recordPermSession(tmps, orm);
} else {
Log.d(TAG, "fail to get permnant session");
if (orm.isUsePermanentSeesion() == false) {
Log.d(TAG, "fail to get permnant session, use tmp session");
recordPermSession(tmps, orm);
} else {
handler.post(
new Runnable() {
public void run() {
Toast.makeText(
FacebookLoginActivity.this,
R.string.facebook_get_permanent_session_failed,
Toast.LENGTH_LONG)
.show();
}
});
}
}
// reset the session and async in activity
AccountManager.login();
handler.post(
new Runnable() {
public void run() {
FacebookLoginActivity.this.setResult(100);
sendMessageToService(true);
}
});
handler.post(
new Runnable() {
public void run() {
quitLooperAndFinish();
}
});
isInProcess = false;
setButtonEnable(true);
}
public static void waitTillDone() {
ThreadHandler th = ThreadHandler.getInstance();
while ((th.d_runningTasks.size() > 0) || (th.d_scheduledTasks.size() > 0)) {
sleep(100);
}
}
