/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.os.cts;

import junit.framework.TestCase;
import android.cts.util.TestThread;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.SystemClock;
import android.os.Handler.Callback;
import android.test.UiThreadTest;
import android.util.Printer;

public class HandlerTest extends TestCase {

    public static final int MESSAGE_WHAT = 3;

    // time when message should be handled.
    static final int RUNTIME = 300;

    // time when check whether the message is handled.
    static final long DELAYED = RUNTIME + 50;

    // Handler
    private final Handler mHandler = new Handler(Looper.getMainLooper());
    private final MockHandler mHandler1 = new MockHandler(Looper.getMainLooper());
    private final Object mLock = new Object();

    @Override
    protected void tearDown() throws Exception {
        mHandler1.reset();
        super.tearDown();
    }

    public void testConstructor() throws Throwable {
        final Callback cb = new Callback() {
            public boolean handleMessage(Message msg) {
                return false;
            }
        };

        new TestThread(new Runnable() {
            public void run() {
                Looper.prepare();
                new Handler();
                new Handler(cb);
            }
        }).runTest(RUNTIME);

        // new the Handler instance
        new Handler(Looper.getMainLooper());
        new Handler(Looper.getMainLooper(), cb);
    }

    public void testPostAtTime1() {
        MockRunnable r = new MockRunnable();
        assertTrue(mHandler.postAtTime(r, SystemClock.uptimeMillis() + RUNTIME));
        assertFalse(r.isRun());
        sleep(DELAYED);
        assertTrue(r.isRun());
        mHandler.removeCallbacks(r);
    }

    public void testPostAtTime2() {
        MockRunnable r = new MockRunnable();
        Object token = new Object();
        assertTrue(mHandler.postAtTime(r, token, SystemClock.uptimeMillis() + RUNTIME));
        assertFalse(r.isRun());
        sleep(DELAYED);
        assertTrue(r.isRun());
        mHandler.removeCallbacks(r);
    }

    public void testSendMessageAtTime() {
        Message msg = mHandler1.obtainMessage();
        assertTrue(mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME));
        assertNull(mHandler1.message);
        sleep(DELAYED);
        assertSame(msg, mHandler1.message);
        mHandler1.removeMessages(msg.what);
    }

    public void testDump() {
        final String prefix = "AndroidTest";
        MockPrinter pw = new MockPrinter();
        mHandler.dump(pw, prefix);
    }

    public void testHasMessagesWithInt() {
        Message msg = mHandler.obtainMessage();
        assertFalse(mHandler.hasMessages(msg.what));
        mHandler.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME);
        assertTrue(mHandler.hasMessages(msg.what));
        mHandler.removeMessages(msg.what);
        assertFalse(mHandler.hasMessages(msg.what));
    }

    public void testHasMessagesWithObject() {
        Message msg = mHandler.obtainMessage();
        msg.obj = new Object();
        assertFalse(mHandler.hasMessages(msg.what, msg.obj));
        mHandler.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME);
        assertTrue(mHandler.hasMessages(msg.what, msg.obj));
        mHandler.removeMessages(msg.what);
        assertFalse(mHandler.hasMessages(msg.what, msg.obj));
    }

    public void testRemoveCallbacksAndMessages() {
        Message msg = mHandler1.obtainMessage();
        mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME);
        sleep(RUNTIME / 2);

        // Test the obj == null
        mHandler1.removeCallbacksAndMessages(null);
        sleep(RUNTIME / 2);
        assertNull(mHandler1.message);
        mHandler1.reset();

        msg = mHandler1.obtainMessage();
        msg.obj = new Object();
        mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME);
        sleep(RUNTIME / 2);

        // Test the obj == p.obj for message
        mHandler1.removeCallbacksAndMessages(msg.obj);
        sleep(RUNTIME / 2);
        assertNull(mHandler1.message);
        mHandler1.reset();

        // Test remove a callback
        final Object obj = new Object();
        MockRunnable mr1 = new MockRunnable();
        mHandler1.postAtTime(mr1, obj, SystemClock.uptimeMillis() + RUNTIME);
        sleep(RUNTIME / 2);
        mHandler1.removeCallbacksAndMessages(obj);
        sleep(RUNTIME / 2);
        assertFalse(mr1.isRun());

        // test remove a wrong callback
        mr1 = new MockRunnable();
        mHandler1.postAtTime(mr1, obj, SystemClock.uptimeMillis() + RUNTIME);
        sleep(DELAYED / 2);
        mHandler1.removeCallbacksAndMessages(new Object());
        sleep(DELAYED / 2);
        assertTrue(mr1.isRun());
    }

    public void testSendEmptyMessageAtTime() {
        long uptime = SystemClock.uptimeMillis() + RUNTIME;
        assertTrue(mHandler1.sendEmptyMessageAtTime(MESSAGE_WHAT, uptime));
        assertEquals(0, mHandler1.what);
        sleep(DELAYED);
        assertEquals(MESSAGE_WHAT, mHandler1.what);
        mHandler1.removeMessages(MESSAGE_WHAT);
    }

    public void testGetLooper() {
        // new the Handler instance
        Looper looper = Looper.getMainLooper();
        Handler handler = new Handler(looper);
        assertSame(looper, handler.getLooper());
    }

    public void testRemoveCallbacks() {
        // test remove right object.
        MockRunnable r = new MockRunnable();
        mHandler.postAtTime(r, SystemClock.uptimeMillis() + RUNTIME);
        sleep(DELAYED / 2);
        mHandler.removeCallbacks(r);
        sleep(DELAYED / 2);
        assertFalse(r.isRun());

        // test remove wrong object.
        r = new MockRunnable();
        MockRunnable mr = new MockRunnable();
        mHandler.postAtTime(r, SystemClock.uptimeMillis() + RUNTIME);
        sleep(DELAYED / 2);
        mHandler.removeCallbacks(mr);
        sleep(DELAYED / 2);
        assertTrue(r.isRun());
    }

    public void testRemoveCallbacksWithObject() {
        // test remove right object.
        MockRunnable r1 = new MockRunnable();
        Object token = new Object();
        mHandler.postAtTime(r1, token, SystemClock.uptimeMillis() + RUNTIME);
        sleep(DELAYED / 2);
        mHandler.removeCallbacks(r1, token);
        sleep(DELAYED / 2);
        assertFalse(r1.isRun());

        // test remove wrong object.
        r1 = new MockRunnable();
        MockRunnable r2 = new MockRunnable();

        mHandler.postAtTime(r1, token, SystemClock.uptimeMillis() + RUNTIME);
        sleep(DELAYED / 2);
        mHandler.removeCallbacks(r2, token);
        sleep(DELAYED / 2);
        assertTrue(r1.isRun());

        // test remove with right callback and wrong token
        mHandler.postAtTime(r1, token, SystemClock.uptimeMillis() + RUNTIME);
        Object wrongToken = new Object();
        sleep(DELAYED / 2);
        mHandler.removeCallbacks(r1, wrongToken);
        sleep(DELAYED / 2);
        assertTrue(r1.isRun());
    }

    public void testRemoveMessages() {
        // test remove right message
        Message msg = mHandler1.obtainMessage();
        msg.what = 100;
        mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME);
        sleep(DELAYED / 2);
        mHandler1.removeMessages(msg.what);
        sleep(DELAYED / 2);
        assertNull(mHandler1.message);
        assertEquals(0, mHandler1.what);
        mHandler1.reset();

        // test remove wrong message
        msg = mHandler1.obtainMessage();
        msg.what = 100;
        mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME);
        sleep(DELAYED / 2);
        mHandler1.removeMessages(101);
        sleep(DELAYED / 2);
        assertEquals(100, mHandler1.what);
    }

    public void testRemoveMessagesWithObject() {
        // test remove right message
        Message msg = mHandler1.obtainMessage();
        msg.obj = new Object();
        msg.what = 100;
        mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME);
        sleep(DELAYED / 2);
        mHandler1.removeMessages(msg.what, msg.obj);
        sleep(DELAYED / 2);
        assertNull(mHandler1.message);
        assertEquals(0, mHandler1.what);
        mHandler1.reset();

        // test remove wrong message
        msg = mHandler1.obtainMessage();
        msg.obj = new Object();
        msg.what = 100;
        Message wrongMessage = mHandler1.obtainMessage();
        wrongMessage.obj = new Object();
        wrongMessage.what = 111;
        mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME);
        sleep(DELAYED / 2);
        mHandler1.removeMessages(msg.what, wrongMessage.obj);
        sleep(DELAYED / 2);
        assertEquals(100, mHandler1.what);
    }

    public void testSendMessage() {
        Message msg = mHandler1.obtainMessage();
        assertTrue(mHandler1.sendMessage(msg));
        sleep(DELAYED);
        assertSame(msg, mHandler1.message);
        mHandler1.removeMessages(msg.what);
    }

    public void testObtainMessage() {
         Message msg = mHandler.obtainMessage();
         assertNotNull(msg);
         assertEquals(mHandler, msg.getTarget());
    }

    public void testObtainMessageWithInt() {
         // new the Handler instance
         Handler handler = new Handler(Looper.getMainLooper());
         Message msg = handler.obtainMessage();
         msg.what = 100;
         Message msg1 = mHandler.obtainMessage(msg.what);
         assertNotNull(msg1);
         assertEquals(mHandler, msg1.getTarget());
         assertEquals(msg.what, msg1.what);
    }

    public void testObtainMessageWithIntObject() {
        // new the Handler instance
        Handler handler = new Handler(Looper.getMainLooper());
        Message msg = handler.obtainMessage();
        msg.what = 100;
        msg.obj = new Object();
        Message msg1 = mHandler.obtainMessage(msg.what, msg.obj);
        assertNotNull(msg1);
        assertEquals(mHandler, msg1.getTarget());
        assertEquals(msg.what, msg1.what);
        assertSame(msg.obj, msg1.obj);
    }

    public void testObtainMessageWithMutiInt() {
        // new the Handler instance
        Handler handler = new Handler(Looper.getMainLooper());
        Message msg = handler.obtainMessage();
        msg.what = 100;
        msg.arg1 = 101;
        msg.arg2 = 102;
        Message msg1 = mHandler.obtainMessage(msg.what, msg.arg1, msg.arg2);
        assertNotNull(msg1);
        assertEquals(mHandler, msg1.getTarget());
        assertEquals(msg.what, msg1.what);
        assertEquals(msg.arg1, msg1.arg1);
        assertEquals(msg.arg2, msg1.arg2);
    }

    public void testObtainMessageWithMutiIntObject() {
        // new the Handler instance
        Handler handler = new Handler(Looper.getMainLooper());
        Message msg = handler.obtainMessage();
        msg.what = 100;
        msg.arg1 = 1000;
        msg.arg2 = 2000;
        msg.obj = new Object();
        Message msg1 = mHandler.obtainMessage(msg.what, msg.arg1, msg.arg2, msg.obj);
        assertNotNull(msg1);
        assertEquals(mHandler, msg1.getTarget());
        assertEquals(msg.arg1, msg1.arg1);
        assertEquals(msg.arg2, msg1.arg2);
        assertSame(msg.obj, msg1.obj);
    }

    public void testSendMessageAtFrontOfQueue() {
        Message lateMsg = mHandler1.obtainMessage();
        mHandler1.sendEmptyMessageAtTime(lateMsg.what, SystemClock.uptimeMillis() + RUNTIME * 5);
        Message msg = mHandler1.obtainMessage();
        msg.what = 100;
        assertTrue(mHandler1.sendMessageAtFrontOfQueue(msg));
        sleep(DELAYED);
        assertSame(msg, mHandler1.message);
        mHandler1.removeMessages(msg.what);
    }

    public void testPostDelayed() {
        MockRunnable r = new MockRunnable();
        assertTrue(mHandler.postDelayed(r, DELAYED));
        assertFalse(r.isRun());
        sleep(DELAYED + 500);
        assertTrue(r.isRun());
        mHandler.removeCallbacks(r);
    }

    public void testPostAtFrontOfQueue() {
        MockRunnable r = new MockRunnable();
        MockRunnable mr = new MockRunnable();
        assertFalse(r.isRun());
        assertTrue(mHandler.postDelayed(mr, DELAYED));
        assertTrue(mHandler.postAtFrontOfQueue(r));
        sleep(DELAYED / 2);
        assertTrue(r.isRun());
        mHandler.removeCallbacks(r);
    }

    public void testSendMessageDelayed() {
        Message msg = mHandler1.obtainMessage();
        assertTrue(mHandler1.sendMessageDelayed(msg, DELAYED));
        assertNull(mHandler1.message);
        sleep(DELAYED + 500);
        assertSame(msg, mHandler1.message);
        mHandler1.removeMessages(msg.what);
    }

    public void testPost() {
        MockRunnable r = new MockRunnable();
        assertFalse(r.isRun());
        assertTrue(mHandler.post(r));
        sleep(DELAYED);
        assertTrue(r.isRun());
        mHandler.removeCallbacks(r);
    }

    public void testSendEmptyMessageDelayed() {
        Message msg = mHandler1.obtainMessage();
        msg.what = 100;
        assertTrue(mHandler1.sendEmptyMessageDelayed(msg.what, DELAYED));
        sleep(DELAYED + 500);
        assertEquals(msg.what, mHandler1.what);
        mHandler1.removeMessages(msg.what);
    }

    public void testDispatchMessage1() {
        // new the Handler instance
        MockHandler handler = new MockHandler();
        MockRunnable callback = new MockRunnable();
        Message msg = Message.obtain(handler, callback);
        handler.dispatchMessage(msg);
        assertNotNull(msg.getCallback());

        // Test the if branch
        assertTrue(callback.isRun());
    }

    public void testDispatchMessage2() {
        // new the Handler instance
        MockHandler handler = new MockHandler();
        Message msg = handler.obtainMessage();
        handler.dispatchMessage(msg);

        // Test the else branch
        assertSame(msg, handler.message);
    }

    public void testSendEmptyMessage() {
        Message msg = mHandler1.obtainMessage();
        msg.what = 100;
        assertTrue(mHandler1.sendEmptyMessage(msg.what));
        sleep(DELAYED);
        assertEquals(msg.what, mHandler1.what);
        mHandler1.removeMessages(msg.what);
    }

    public void testToString() {
        assertNotNull(mHandler1.toString());
    }

    /**
     * MockRunnable
     */
    private class MockRunnable implements Runnable {
        // MockRunnable run
        private boolean mIsRun;

        public void run() {
            mIsRun = true;
        }

        public boolean isRun() {
            return mIsRun;
        }
    }

    /**
     * MockPrinter
     */
    private class MockPrinter implements Printer {
        String mOutput;

        public void println(String x) {
            mOutput = x;
        }

        public String getPrint() {
            return mOutput;
        }
    }

    /**
     * MockHandler
     */
    private class MockHandler extends Handler {
        public Message message;
        public int what;

        MockHandler() {
            super(Looper.getMainLooper());
        }

        MockHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            message = msg;
            what = message.what;
        }

        public void reset() {
            message = null;
            what = 0;
        }
    }

    public void sleep(long time) {
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            fail(e.getMessage());
        }
    }
}