1 /* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.os.cts; 18 19 import junit.framework.TestCase; 20 import android.os.Handler; 21 import android.os.Looper; 22 import android.os.Message; 23 import android.os.SystemClock; 24 import android.os.Handler.Callback; 25 import android.util.Printer; 26 27 public class HandlerTest extends TestCase { 28 29 public static final int MESSAGE_WHAT = 3; 30 31 // time when message should be handled. 32 static final int RUNTIME = 300; 33 34 // time when check whether the message is handled. 35 static final long DELAYED = RUNTIME + 50; 36 37 // Handler 38 Handler mHandler = new Handler(); 39 MockHandler mHandler1 = new MockHandler(); 40 41 @Override 42 protected void tearDown() throws Exception { 43 mHandler1.reset(); 44 super.tearDown(); 45 } 46 47 public void testConstructor() { 48 Callback cb = new Callback() { 49 public boolean handleMessage(Message msg) { 50 return false; 51 } 52 }; 53 54 // new the Handler instance 55 new Handler(); 56 new Handler(Looper.myLooper()); 57 new Handler(cb); 58 new Handler(Looper.myLooper(), cb); 59 } 60 61 public void testPostAtTime1() { 62 MockRunnable r = new MockRunnable(); 63 assertTrue(mHandler.postAtTime(r, SystemClock.uptimeMillis() + RUNTIME)); 64 assertFalse(r.isRun()); 65 sleep(DELAYED); 66 assertTrue(r.isRun()); 67 mHandler.removeCallbacks(r); 68 } 69 70 public void testPostAtTime2() { 71 MockRunnable r = new MockRunnable(); 72 Object token = new Object(); 73 assertTrue(mHandler.postAtTime(r, token, SystemClock.uptimeMillis() + RUNTIME)); 74 assertFalse(r.isRun()); 75 sleep(DELAYED); 76 assertTrue(r.isRun()); 77 mHandler.removeCallbacks(r); 78 } 79 80 public void testSendMessageAtTime() { 81 Message msg = mHandler1.obtainMessage(); 82 assertTrue(mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME)); 83 assertNull(mHandler1.message); 84 sleep(DELAYED); 85 assertSame(msg, mHandler1.message); 86 mHandler1.removeMessages(msg.what); 87 } 88 89 public void testDump() { 90 final String prefix = "AndroidTest"; 91 MockPrinter pw = new MockPrinter(); 92 mHandler.dump(pw, prefix); 93 } 94 95 public void testHasMessagesWithInt() { 96 Message msg = mHandler.obtainMessage(); 97 assertFalse(mHandler.hasMessages(msg.what)); 98 mHandler.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME); 99 assertTrue(mHandler.hasMessages(msg.what)); 100 mHandler.removeMessages(msg.what); 101 assertFalse(mHandler.hasMessages(msg.what)); 102 } 103 104 public void testHasMessagesWithObject() { 105 Message msg = mHandler.obtainMessage(); 106 msg.obj = new Object(); 107 assertFalse(mHandler.hasMessages(msg.what, msg.obj)); 108 mHandler.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME); 109 assertTrue(mHandler.hasMessages(msg.what, msg.obj)); 110 mHandler.removeMessages(msg.what); 111 assertFalse(mHandler.hasMessages(msg.what, msg.obj)); 112 } 113 114 public void testRemoveCallbacksAndMessages() { 115 Message msg = mHandler1.obtainMessage(); 116 mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME); 117 sleep(RUNTIME / 2); 118 119 // Test the obj == null 120 mHandler1.removeCallbacksAndMessages(null); 121 sleep(RUNTIME / 2); 122 assertNull(mHandler1.message); 123 mHandler1.reset(); 124 125 msg = mHandler1.obtainMessage(); 126 msg.obj = new Object(); 127 mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME); 128 sleep(RUNTIME / 2); 129 130 // Test the obj == p.obj for message 131 mHandler1.removeCallbacksAndMessages(msg.obj); 132 sleep(RUNTIME / 2); 133 assertNull(mHandler1.message); 134 mHandler1.reset(); 135 136 // Test remove a callback 137 final Object obj = new Object(); 138 MockRunnable mr1 = new MockRunnable(); 139 mHandler1.postAtTime(mr1, obj, SystemClock.uptimeMillis() + RUNTIME); 140 sleep(RUNTIME / 2); 141 mHandler1.removeCallbacksAndMessages(obj); 142 sleep(RUNTIME / 2); 143 assertFalse(mr1.isRun()); 144 145 // test remove a wrong callback 146 mr1 = new MockRunnable(); 147 mHandler1.postAtTime(mr1, obj, SystemClock.uptimeMillis() + RUNTIME); 148 sleep(DELAYED / 2); 149 mHandler1.removeCallbacksAndMessages(new Object()); 150 sleep(DELAYED / 2); 151 assertTrue(mr1.isRun()); 152 } 153 154 public void testSendEmptyMessageAtTime() { 155 long uptime = SystemClock.uptimeMillis() + RUNTIME; 156 assertTrue(mHandler1.sendEmptyMessageAtTime(MESSAGE_WHAT, uptime)); 157 assertEquals(0, mHandler1.what); 158 sleep(DELAYED); 159 assertEquals(MESSAGE_WHAT, mHandler1.what); 160 mHandler1.removeMessages(MESSAGE_WHAT); 161 } 162 163 public void testGetLooper() { 164 // new the Handler instance 165 Looper looper = Looper.myLooper(); 166 mHandler = new Handler(looper); 167 assertSame(looper, mHandler.getLooper()); 168 } 169 170 public void testRemoveCallbacks() { 171 // test remove right object. 172 MockRunnable r = new MockRunnable(); 173 mHandler.postAtTime(r, SystemClock.uptimeMillis() + RUNTIME); 174 sleep(DELAYED / 2); 175 mHandler.removeCallbacks(r); 176 sleep(DELAYED / 2); 177 assertFalse(r.isRun()); 178 179 // test remove wrong object. 180 r = new MockRunnable(); 181 MockRunnable mr = new MockRunnable(); 182 mHandler.postAtTime(r, SystemClock.uptimeMillis() + RUNTIME); 183 sleep(DELAYED / 2); 184 mHandler.removeCallbacks(mr); 185 sleep(DELAYED / 2); 186 assertTrue(r.isRun()); 187 } 188 189 public void testRemoveCallbacksWithObject() { 190 // test remove right object. 191 MockRunnable r1 = new MockRunnable(); 192 Object token = new Object(); 193 mHandler.postAtTime(r1, token, SystemClock.uptimeMillis() + RUNTIME); 194 sleep(DELAYED / 2); 195 mHandler.removeCallbacks(r1, token); 196 sleep(DELAYED / 2); 197 assertFalse(r1.isRun()); 198 199 // test remove wrong object. 200 r1 = new MockRunnable(); 201 MockRunnable r2 = new MockRunnable(); 202 203 mHandler.postAtTime(r1, token, SystemClock.uptimeMillis() + RUNTIME); 204 sleep(DELAYED / 2); 205 mHandler.removeCallbacks(r2, token); 206 sleep(DELAYED / 2); 207 assertTrue(r1.isRun()); 208 209 // test remove with right callback and wrong token 210 mHandler.postAtTime(r1, token, SystemClock.uptimeMillis() + RUNTIME); 211 Object wrongToken = new Object(); 212 sleep(DELAYED / 2); 213 mHandler.removeCallbacks(r1, wrongToken); 214 sleep(DELAYED / 2); 215 assertTrue(r1.isRun()); 216 } 217 218 public void testRemoveMessages() { 219 // test remove right message 220 Message msg = mHandler1.obtainMessage(); 221 msg.what = 100; 222 mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME); 223 sleep(DELAYED / 2); 224 mHandler1.removeMessages(msg.what); 225 sleep(DELAYED / 2); 226 assertNull(mHandler1.message); 227 assertEquals(0, mHandler1.what); 228 mHandler1.reset(); 229 230 // test remove wrong message 231 msg = mHandler1.obtainMessage(); 232 msg.what = 100; 233 mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME); 234 sleep(DELAYED / 2); 235 mHandler1.removeMessages(101); 236 sleep(DELAYED / 2); 237 assertEquals(100, mHandler1.what); 238 } 239 240 public void testRemoveMessagesWithObject() { 241 // test remove right message 242 Message msg = mHandler1.obtainMessage(); 243 msg.obj = new Object(); 244 msg.what = 100; 245 mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME); 246 sleep(DELAYED / 2); 247 mHandler1.removeMessages(msg.what, msg.obj); 248 sleep(DELAYED / 2); 249 assertNull(mHandler1.message); 250 assertEquals(0, mHandler1.what); 251 mHandler1.reset(); 252 253 // test remove wrong message 254 msg = mHandler1.obtainMessage(); 255 msg.obj = new Object(); 256 msg.what = 100; 257 Message wrongMessage = mHandler1.obtainMessage(); 258 wrongMessage.obj = new Object(); 259 wrongMessage.what = 111; 260 mHandler1.sendMessageAtTime(msg, SystemClock.uptimeMillis() + RUNTIME); 261 sleep(DELAYED / 2); 262 mHandler1.removeMessages(msg.what, wrongMessage.obj); 263 sleep(DELAYED / 2); 264 assertEquals(100, mHandler1.what); 265 } 266 267 public void testSendMessage() { 268 Message msg = mHandler1.obtainMessage(); 269 assertTrue(mHandler1.sendMessage(msg)); 270 sleep(DELAYED); 271 assertSame(msg, mHandler1.message); 272 mHandler1.removeMessages(msg.what); 273 } 274 275 public void testObtainMessage() { 276 Message msg = mHandler.obtainMessage(); 277 assertNotNull(msg); 278 assertEquals(mHandler, msg.getTarget()); 279 } 280 281 public void testObtainMessageWithInt() { 282 // new the Handler instance 283 Handler handler = new Handler(); 284 Message msg = handler.obtainMessage(); 285 msg.what = 100; 286 Message msg1 = mHandler.obtainMessage(msg.what); 287 assertNotNull(msg1); 288 assertEquals(mHandler, msg1.getTarget()); 289 assertEquals(msg.what, msg1.what); 290 } 291 292 public void testObtainMessageWithIntObject() { 293 // new the Handler instance 294 Handler handler = new Handler(); 295 Message msg = handler.obtainMessage(); 296 msg.what = 100; 297 msg.obj = new Object(); 298 Message msg1 = mHandler.obtainMessage(msg.what, msg.obj); 299 assertNotNull(msg1); 300 assertEquals(mHandler, msg1.getTarget()); 301 assertEquals(msg.what, msg1.what); 302 assertSame(msg.obj, msg1.obj); 303 } 304 305 public void testObtainMessageWithMutiInt() { 306 // new the Handler instance 307 Handler handler = new Handler(); 308 Message msg = handler.obtainMessage(); 309 msg.what = 100; 310 msg.arg1 = 101; 311 msg.arg2 = 102; 312 Message msg1 = mHandler.obtainMessage(msg.what, msg.arg1, msg.arg2); 313 assertNotNull(msg1); 314 assertEquals(mHandler, msg1.getTarget()); 315 assertEquals(msg.what, msg1.what); 316 assertEquals(msg.arg1, msg1.arg1); 317 assertEquals(msg.arg2, msg1.arg2); 318 } 319 320 public void testObtainMessageWithMutiIntObject() { 321 // new the Handler instance 322 Handler handler = new Handler(); 323 Message msg = handler.obtainMessage(); 324 msg.what = 100; 325 msg.arg1 = 1000; 326 msg.arg2 = 2000; 327 msg.obj = new Object(); 328 Message msg1 = mHandler.obtainMessage(msg.what, msg.arg1, msg.arg2, msg.obj); 329 assertNotNull(msg1); 330 assertEquals(mHandler, msg1.getTarget()); 331 assertEquals(msg.arg1, msg1.arg1); 332 assertEquals(msg.arg2, msg1.arg2); 333 assertSame(msg.obj, msg1.obj); 334 } 335 336 public void testSendMessageAtFrontOfQueue() { 337 Message lateMsg = mHandler1.obtainMessage(); 338 mHandler1.sendEmptyMessageAtTime(lateMsg.what, SystemClock.uptimeMillis() + RUNTIME * 5); 339 Message msg = mHandler1.obtainMessage(); 340 msg.what = 100; 341 assertTrue(mHandler1.sendMessageAtFrontOfQueue(msg)); 342 sleep(DELAYED); 343 assertSame(msg, mHandler1.message); 344 mHandler1.removeMessages(msg.what); 345 } 346 347 public void testPostDelayed() { 348 MockRunnable r = new MockRunnable(); 349 assertTrue(mHandler.postDelayed(r, DELAYED)); 350 assertFalse(r.isRun()); 351 sleep(DELAYED + 500); 352 assertTrue(r.isRun()); 353 mHandler.removeCallbacks(r); 354 } 355 356 public void testPostAtFrontOfQueue() { 357 MockRunnable r = new MockRunnable(); 358 MockRunnable mr = new MockRunnable(); 359 assertFalse(r.isRun()); 360 assertTrue(mHandler.postDelayed(mr, DELAYED)); 361 assertTrue(mHandler.postAtFrontOfQueue(r)); 362 sleep(DELAYED / 2); 363 assertTrue(r.isRun()); 364 mHandler.removeCallbacks(r); 365 } 366 367 public void testSendMessageDelayed() { 368 Message msg = mHandler1.obtainMessage(); 369 assertTrue(mHandler1.sendMessageDelayed(msg, DELAYED)); 370 assertNull(mHandler1.message); 371 sleep(DELAYED + 500); 372 assertSame(msg, mHandler1.message); 373 mHandler1.removeMessages(msg.what); 374 } 375 376 public void testPost() { 377 MockRunnable r = new MockRunnable(); 378 assertFalse(r.isRun()); 379 assertTrue(mHandler.post(r)); 380 sleep(DELAYED); 381 assertTrue(r.isRun()); 382 mHandler.removeCallbacks(r); 383 } 384 385 public void testSendEmptyMessageDelayed() { 386 Message msg = mHandler1.obtainMessage(); 387 msg.what = 100; 388 assertTrue(mHandler1.sendEmptyMessageDelayed(msg.what, DELAYED)); 389 sleep(DELAYED + 500); 390 assertEquals(msg.what, mHandler1.what); 391 mHandler1.removeMessages(msg.what); 392 } 393 394 public void testDispatchMessage1() { 395 // new the Handler instance 396 MockHandler handler = new MockHandler(); 397 MockRunnable callback = new MockRunnable(); 398 Message msg = Message.obtain(handler, callback); 399 handler.dispatchMessage(msg); 400 assertNotNull(msg.getCallback()); 401 402 // Test the if branch 403 assertTrue(callback.isRun()); 404 } 405 406 public void testDispatchMessage2() { 407 // new the Handler instance 408 MockHandler handler = new MockHandler(); 409 Message msg = handler.obtainMessage(); 410 handler.dispatchMessage(msg); 411 412 // Test the else branch 413 assertSame(msg, handler.message); 414 } 415 416 public void testSendEmptyMessage() { 417 Message msg = mHandler1.obtainMessage(); 418 msg.what = 100; 419 assertTrue(mHandler1.sendEmptyMessage(msg.what)); 420 sleep(DELAYED); 421 assertEquals(msg.what, mHandler1.what); 422 mHandler1.removeMessages(msg.what); 423 } 424 425 public void testToString() { 426 assertNotNull(mHandler1.toString()); 427 } 428 429 /** 430 * MockRunnable 431 */ 432 private class MockRunnable implements Runnable { 433 // MockRunnable run 434 private boolean mIsRun; 435 436 public void run() { 437 mIsRun = true; 438 } 439 440 public boolean isRun() { 441 return mIsRun; 442 } 443 } 444 445 /** 446 * MockPrinter 447 */ 448 private class MockPrinter implements Printer { 449 String mOutput; 450 451 public void println(String x) { 452 mOutput = x; 453 } 454 455 public String getPrint() { 456 return mOutput; 457 } 458 } 459 460 /** 461 * MockHandler 462 */ 463 private class MockHandler extends Handler { 464 public Message message; 465 public int what; 466 467 @Override 468 public void handleMessage(Message msg) { 469 message = msg; 470 what = message.what; 471 } 472 473 public void reset() { 474 message = null; 475 what = 0; 476 } 477 } 478 479 public void sleep(long time) { 480 try { 481 Thread.sleep(time); 482 } catch (InterruptedException e) { 483 fail(e.getMessage()); 484 } 485 } 486 } 487
