Code example for CountDownLatch

Methods: await, getCount, sleep

0
    public static class PseudoActivity extends Thread {
        private TestTask theTask;
        private final CountDownLatch loadLatch = new CountDownLatch(1);
        private final CountDownLatch startLatch = new CountDownLatch(1);
        private final CountDownLatch checkLatch = new CountDownLatch(1);
        private final CountDownLatch endLatch = new CountDownLatch(1);
        public Handler mHandler;
        public void run() { 
            Looper.prepare();
            theTask = new TestTask();
            loadLatch.countDown();
            mHandler = new Handler() {
                @Override 
                public void handleMessage(Message msg) {
                    // do nothing 
                } 
            }; 
            Looper.loop();
        } 
        public AsyncTask<Void, Void, Void> getTask() {
            return theTask;
        } 
        public void startSync() throws InterruptedException { 
            start();
            loadLatch.await(5000, TimeUnit.MILLISECONDS);
        } 
        public void waitForStart() throws InterruptedException { 
            startLatch.await(5000, TimeUnit.MILLISECONDS);
        } 
        public boolean isStarted() { 
            return startLatch.getCount() == 0;
        } 
        public void checkPoint() { 
            checkLatch.countDown();
        } 
        public void waitForEnd() throws InterruptedException { 
            endLatch.await(5000, TimeUnit.MILLISECONDS);
        } 
        public boolean isEnded() { 
            return endLatch.getCount() == 0;
        } 
        private class TestTask extends AsyncTask<Void, Void, Void> {
            @Override 
            protected Void doInBackground(Void... params) {
                startLatch.countDown();
                try { 
                    checkLatch.await(5000, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    fail("interrupted");
                } 
                return null; 
            } 
            @Override 
            protected void onPostExecute(Void result) {
                super.onPostExecute(result);
                endLatch.countDown();
            } 
        }; 
    } 
     
    public void testIsRunning() { 
        assertFalse("null is false", AsyncTaskUtils.isRunning(null));
         
        PseudoActivity a = new PseudoActivity();
        try { 
            a.startSync();
        } catch (InterruptedException e1) {
            fail("interrupted");
        } 
        assertFalse("not start", AsyncTaskUtils.isRunning(a.getTask()));
 
        // start and wait for the task start running 
        a.getTask().execute();
 
        try { 
            a.waitForStart();
        } catch (InterruptedException e) {
            fail("interrupted");
        } 
        assertTrue("the task has been started", a.isStarted());
        assertTrue("running", AsyncTaskUtils.isRunning(a.getTask()));
         
        a.checkPoint();
         
        // wait for the task ends 
        try { 
            a.waitForEnd();
        } catch (InterruptedException e) {
            fail("interrupted");
        } 
        assertTrue("the task was finished", a.isEnded());
         
        // probably some time required to change the state 
        try { 
            Thread.sleep(500);
        } catch (InterruptedException e) {
            fail("interrupted");
        } 
         
        assertFalse("finished", AsyncTaskUtils.isRunning(a.getTask()));