1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package org.apache.harmony.luni.tests.java.lang; 19 20 import java.io.ByteArrayOutputStream; 21 import java.io.PrintStream; 22 import java.lang.Thread.UncaughtExceptionHandler; 23 import java.security.Permission; 24 import java.util.Map; 25 import java.util.concurrent.Semaphore; 26 import java.util.concurrent.locks.LockSupport; 27 import java.util.concurrent.atomic.AtomicReference; 28 29 import dalvik.annotation.AndroidOnly; 30 import dalvik.annotation.TestLevel; 31 import dalvik.annotation.TestTargetClass; 32 import dalvik.annotation.TestTargetNew; 33 import dalvik.annotation.TestTargets; 34 35 @TestTargetClass(Thread.class) 36 public class ThreadTest extends junit.framework.TestCase { 37 38 int counter = 0; 39 40 static class SimpleThread implements Runnable { 41 int delay; 42 43 public void run() { 44 try { 45 synchronized (this) { 46 this.notify(); 47 this.wait(delay); 48 } 49 } catch (InterruptedException e) { 50 return; 51 } 52 53 } 54 55 public SimpleThread(int d) { 56 if (d >= 0) 57 delay = d; 58 } 59 } 60 61 static class YieldThread implements Runnable { 62 volatile int delay; 63 64 public void run() { 65 int x = 0; 66 while (true) { 67 ++x; 68 } 69 } 70 71 public YieldThread(int d) { 72 if (d >= 0) 73 delay = d; 74 } 75 } 76 77 static class ResSupThread implements Runnable { 78 Thread parent; 79 80 volatile int checkVal = -1; 81 82 public void run() { 83 try { 84 synchronized (this) { 85 this.notify(); 86 } 87 while (true) { 88 checkVal++; 89 zz(); 90 Thread.sleep(100); 91 } 92 } catch (InterruptedException e) { 93 return; 94 } catch (BogusException e) { 95 try { 96 // Give parent a chance to sleep 97 Thread.sleep(500); 98 } catch (InterruptedException x) { 99 } 100 parent.interrupt(); 101 while (!Thread.currentThread().isInterrupted()) { 102 // Don't hog the CPU 103 try { 104 Thread.sleep(50); 105 } catch (InterruptedException x) { 106 // This is what we've been waiting for...don't throw it 107 // away! 108 break; 109 } 110 } 111 } 112 } 113 114 public void zz() throws BogusException { 115 } 116 117 public ResSupThread(Thread t) { 118 parent = t; 119 } 120 121 public synchronized int getCheckVal() { 122 return checkVal; 123 } 124 } 125 126 static class BogusException extends Throwable { 127 128 private static final long serialVersionUID = 1L; 129 130 public BogusException(String s) { 131 super(s); 132 } 133 } 134 135 // TODO android-added 136 class MonitoredClass { 137 public synchronized void enterLocked() { 138 boolean b = Thread.holdsLock(this); 139 assertTrue("Thread should hold lock for object", b); 140 } 141 142 public void enterNonLocked() { 143 boolean b = Thread.holdsLock(this); 144 assertFalse("Thread should not hold lock for object", b); 145 } 146 } 147 148 Thread st, ct, spinner; 149 150 static boolean calledMySecurityManager = false; 151 152 boolean wasInterrupted = false; 153 154 /** 155 * @tests java.lang.Thread#Thread() 156 */ 157 @TestTargetNew( 158 level = TestLevel.COMPLETE, 159 notes = "", 160 method = "Thread", 161 args = {} 162 ) 163 public void test_Constructor() { 164 // Test for method java.lang.Thread() 165 166 Thread t; 167 SecurityManager m = new SecurityManager() { 168 @Override 169 public ThreadGroup getThreadGroup() { 170 calledMySecurityManager = true; 171 return Thread.currentThread().getThreadGroup(); 172 } 173 174 @Override 175 public void checkPermission(Permission permission) { 176 if (permission.getName().equals("setSecurityManager")) { 177 return; 178 } 179 super.checkPermission(permission); 180 } 181 }; 182 try { 183 // To see if it checks Thread creation with our SecurityManager 184 System.setSecurityManager(m); 185 t = new Thread(); 186 } finally { 187 // restore original, no side-effects 188 System.setSecurityManager(null); 189 } 190 assertTrue("Did not call SecurityManager.getThreadGroup ()", 191 calledMySecurityManager); 192 t.start(); 193 } 194 195 /** 196 * @tests java.lang.Thread#Thread(java.lang.Runnable) 197 */ 198 @TestTargetNew( 199 level = TestLevel.COMPLETE, 200 notes = "", 201 method = "Thread", 202 args = {java.lang.Runnable.class} 203 ) 204 public void test_ConstructorLjava_lang_Runnable() { 205 // Test for method java.lang.Thread(java.lang.Runnable) 206 try { 207 ct = new Thread(new SimpleThread(10)); 208 ct.start(); 209 } catch (Exception e) { 210 fail("Failed to create subthread : " + e.getMessage()); 211 } 212 } 213 214 /** 215 * @tests java.lang.Thread#Thread(java.lang.Runnable, java.lang.String) 216 */ 217 @TestTargetNew( 218 level = TestLevel.COMPLETE, 219 notes = "", 220 method = "Thread", 221 args = {java.lang.Runnable.class, java.lang.String.class} 222 ) 223 public void test_ConstructorLjava_lang_RunnableLjava_lang_String() { 224 // Test for method java.lang.Thread(java.lang.Runnable, 225 // java.lang.String) 226 Thread st1 = new Thread(new SimpleThread(1), "SimpleThread1"); 227 assertEquals("Constructed thread with incorrect thread name", "SimpleThread1", st1 228 .getName()); 229 st1.start(); 230 } 231 232 /** 233 * @tests java.lang.Thread#Thread(java.lang.String) 234 */ 235 @TestTargetNew( 236 level = TestLevel.COMPLETE, 237 notes = "", 238 method = "Thread", 239 args = {java.lang.String.class} 240 ) 241 public void test_ConstructorLjava_lang_String() { 242 // Test for method java.lang.Thread(java.lang.String) 243 Thread t = new Thread("Testing"); 244 assertEquals("Created tread with incorrect name", 245 "Testing", t.getName()); 246 t.start(); 247 } 248 249 /** 250 * @tests java.lang.Thread#Thread(java.lang.ThreadGroup, java.lang.Runnable) 251 */ 252 @TestTargetNew( 253 level = TestLevel.COMPLETE, 254 notes = "", 255 method = "Thread", 256 args = {java.lang.ThreadGroup.class, java.lang.Runnable.class} 257 ) 258 public void test_ConstructorLjava_lang_ThreadGroupLjava_lang_Runnable() { 259 // Test for method java.lang.Thread(java.lang.ThreadGroup, 260 // java.lang.Runnable) 261 ThreadGroup tg = new ThreadGroup("Test Group1"); 262 st = new Thread(tg, new SimpleThread(1), "SimpleThread2"); 263 assertTrue("Returned incorrect thread group", st.getThreadGroup() == tg); 264 st.start(); 265 try { 266 st.join(); 267 } catch (InterruptedException e) { 268 } 269 tg.destroy(); 270 } 271 272 /** 273 * @tests java.lang.Thread#Thread(java.lang.ThreadGroup, java.lang.Runnable, 274 * java.lang.String)lo 275 */ 276 @TestTargetNew( 277 level = TestLevel.COMPLETE, 278 notes = "", 279 method = "Thread", 280 args = {java.lang.ThreadGroup.class, java.lang.Runnable.class, java.lang.String.class} 281 ) 282 public void test_ConstructorLjava_lang_ThreadGroupLjava_lang_RunnableLjava_lang_String() { 283 // Test for method java.lang.Thread(java.lang.ThreadGroup, 284 // java.lang.Runnable, java.lang.String) 285 ThreadGroup tg = new ThreadGroup("Test Group2"); 286 st = new Thread(tg, new SimpleThread(1), "SimpleThread3"); 287 assertTrue("Constructed incorrect thread", (st.getThreadGroup() == tg) 288 && st.getName().equals("SimpleThread3")); 289 st.start(); 290 try { 291 st.join(); 292 } catch (InterruptedException e) { 293 } 294 tg.destroy(); 295 296 Runnable r = new Runnable() { 297 public void run() { 298 } 299 }; 300 301 ThreadGroup foo = null; 302 try { 303 new Thread(foo = new ThreadGroup("foo"), r, null); 304 // Should not get here 305 fail("Null cannot be accepted as Thread name"); 306 } catch (NullPointerException npe) { 307 assertTrue("Null cannot be accepted as Thread name", true); 308 foo.destroy(); 309 } 310 } 311 312 @TestTargetNew( 313 level = TestLevel.COMPLETE, 314 notes = "", 315 method = "Thread", 316 args = {java.lang.ThreadGroup.class, java.lang.Runnable.class, java.lang.String.class, long.class} 317 ) 318 public void test_ConstructorLjava_lang_ThreadGroupLjava_lang_RunnableLjava_lang_StringL$L() { 319 ThreadGroup tg = new ThreadGroup("Test Group2"); 320 st = new Thread(tg, new SimpleThread(1), "SimpleThread3", 1); 321 assertTrue("Constructed incorrect thread", (st.getThreadGroup() == tg) 322 && st.getName().equals("SimpleThread3")); 323 st.start(); 324 try { 325 st.join(); 326 } catch (InterruptedException e) { 327 } 328 tg.destroy(); 329 330 Runnable r = new Runnable() { 331 public void run() { 332 } 333 }; 334 335 try { 336 new Thread(tg, new SimpleThread(1), "SimpleThread3", 337 Integer.MAX_VALUE); 338 fail("StackOverflowError/OutOfMemoryError is not thrown."); 339 } catch(IllegalThreadStateException itse) { 340 //expected 341 } 342 343 } 344 345 /** 346 * @tests java.lang.Thread#Thread(java.lang.ThreadGroup, java.lang.String) 347 */ 348 @TestTargetNew( 349 level = TestLevel.COMPLETE, 350 notes = "", 351 method = "Thread", 352 args = {java.lang.ThreadGroup.class, java.lang.String.class} 353 ) 354 public void test_ConstructorLjava_lang_ThreadGroupLjava_lang_String() { 355 // Test for method java.lang.Thread(java.lang.ThreadGroup, 356 // java.lang.String) 357 st = new Thread(new SimpleThread(1), "SimpleThread4"); 358 assertEquals("Returned incorrect thread name", 359 "SimpleThread4", st.getName()); 360 st.start(); 361 } 362 363 /** 364 * @tests java.lang.Thread#activeCount() 365 */ 366 @TestTargetNew( 367 level = TestLevel.COMPLETE, 368 notes = "", 369 method = "activeCount", 370 args = {} 371 ) 372 public void test_activeCount() { 373 // Test for method int java.lang.Thread.activeCount() 374 Thread t = new Thread(new SimpleThread(1)); 375 int active = Thread.activeCount(); 376 assertTrue("Incorrect read made: " + active, active > 0); 377 t.start(); 378 try { 379 t.join(); 380 } catch (InterruptedException e) { 381 } 382 } 383 384 /** 385 * @tests java.lang.Thread#checkAccess() 386 */ 387 @TestTargetNew( 388 level = TestLevel.COMPLETE, 389 notes = "", 390 method = "checkAccess", 391 args = {} 392 ) 393 public void test_checkAccess() { 394 // Test for method void java.lang.Thread.checkAccess() 395 ThreadGroup tg = new ThreadGroup("Test Group3"); 396 try { 397 st = new Thread(tg, new SimpleThread(1), "SimpleThread5"); 398 st.checkAccess(); 399 assertTrue("CheckAccess passed", true); 400 } catch (SecurityException e) { 401 fail("CheckAccess failed : " + e.getMessage()); 402 } 403 st.start(); 404 try { 405 st.join(); 406 } catch (InterruptedException e) { 407 } 408 tg.destroy(); 409 410 SecurityManager sm = new SecurityManager() { 411 412 public void checkPermission(Permission perm) { 413 } 414 415 public void checkAccess(Thread t) { 416 throw new SecurityException(); 417 } 418 }; 419 420 SecurityManager oldSm = System.getSecurityManager(); 421 System.setSecurityManager(sm); 422 try { 423 st.checkAccess(); 424 fail("Should throw SecurityException"); 425 } catch (SecurityException e) { 426 // expected 427 } finally { 428 System.setSecurityManager(oldSm); 429 } 430 } 431 432 /** 433 * @tests java.lang.Thread#countStackFrames() 434 */ 435 @TestTargetNew( 436 level = TestLevel.COMPLETE, 437 notes = "", 438 method = "countStackFrames", 439 args = {} 440 ) 441 @SuppressWarnings("deprecation") 442 public void test_countStackFrames() { 443 /* 444 * Thread.countStackFrames() is unpredictable, so we just test that it 445 * doesn't throw an exception. 446 */ 447 try { 448 Thread.currentThread().countStackFrames(); 449 } catch (Throwable t) { 450 fail("unexpected throwable: " + t.toString()); 451 } 452 } 453 454 /** 455 * @tests java.lang.Thread#currentThread() 456 */ 457 @TestTargetNew( 458 level = TestLevel.COMPLETE, 459 notes = "", 460 method = "currentThread", 461 args = {} 462 ) 463 public void test_currentThread() { 464 assertNotNull(Thread.currentThread()); 465 } 466 467 /** 468 * @tests java.lang.Thread#destroy() 469 */ 470 @TestTargetNew( 471 level = TestLevel.COMPLETE, 472 notes = "", 473 method = "destroy", 474 args = {} 475 ) 476 @SuppressWarnings("deprecation") 477 public void test_destroy() { 478 try { 479 new Thread().destroy(); 480 // FIXME uncomment when IBM VME is updated 481 fail("NoSuchMethodError was not thrown"); 482 } catch (NoSuchMethodError e) { 483 } 484 } 485 486 @TestTargetNew( 487 level = TestLevel.COMPLETE, 488 notes = "", 489 method = "dumpStack", 490 args = {} 491 ) 492 public void test_dumpStack() { 493 try { 494 PrintStream savedErr = System.err; 495 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 496 System.setErr(new PrintStream(baos)); 497 Thread.dumpStack(); 498 System.setErr(savedErr); 499 500 String s = new String(baos.toByteArray()); 501 502 assertTrue(s.contains("java.lang.Thread.dumpStack")); 503 504 } catch(Exception e) { 505 fail("Unexpected exception was thrown: " + e.toString()); 506 } 507 } 508 509 /** 510 * @tests java.lang.Thread#enumerate(java.lang.Thread[]) 511 */ 512 @TestTargetNew( 513 level = TestLevel.COMPLETE, 514 notes = "", 515 method = "enumerate", 516 args = {java.lang.Thread[].class} 517 ) 518 public void test_enumerate$Ljava_lang_Thread() { 519 // Test for method int java.lang.Thread.enumerate(java.lang.Thread []) 520 // The test has been updated according to HARMONY-1974 JIRA issue. 521 522 class MyThread extends Thread { 523 MyThread(ThreadGroup tg, String name) { 524 super(tg, name); 525 } 526 527 boolean failed = false; 528 String failMessage = null; 529 530 public void run() { 531 SimpleThread st1 = null; 532 SimpleThread st2 = null; 533 ThreadGroup mytg = null; 534 Thread firstOne = null; 535 Thread secondOne = null; 536 try { 537 int arrayLength = 10; 538 Thread[] tarray = new Thread[arrayLength]; 539 st1 = new SimpleThread(-1); 540 st2 = new SimpleThread(-1); 541 mytg = new ThreadGroup("jp"); 542 firstOne = new Thread(mytg, st1, "firstOne2"); 543 secondOne = new Thread(mytg, st2, "secondOne1"); 544 int orgCount = Thread.enumerate(tarray); 545 synchronized (st1) { 546 firstOne.start(); 547 try { 548 st1.wait(); 549 } catch (InterruptedException e) { 550 } 551 } 552 int count = Thread.enumerate(tarray); 553 assertEquals("Incorrect value returned2", 554 orgCount + 1, count); 555 synchronized (st2) { 556 secondOne.start(); 557 try { 558 st2.wait(); 559 } catch (InterruptedException e) { 560 } 561 } 562 count = Thread.enumerate(tarray); 563 assertEquals("Incorrect value returned3", 564 orgCount + 2, count); 565 } catch (junit.framework.AssertionFailedError e) { 566 failed = true; 567 failMessage = e.getMessage(); 568 e.printStackTrace(); 569 } finally { 570 synchronized (st1) { 571 firstOne.interrupt(); 572 } 573 synchronized (st2) { 574 secondOne.interrupt(); 575 } 576 try { 577 firstOne.join(); 578 secondOne.join(); 579 } catch (InterruptedException e) { 580 } 581 mytg.destroy(); 582 } 583 } 584 }; 585 586 ThreadGroup tg = new ThreadGroup("tg"); 587 MyThread t = new MyThread(tg, "top"); 588 t.start(); 589 try { 590 t.join(); 591 } catch (InterruptedException e) { 592 fail("Unexpected interrupt"); 593 } finally { 594 tg.destroy(); 595 } 596 assertFalse(t.failMessage, t.failed); 597 } 598 599 /** 600 * @tests java.lang.Thread#getContextClassLoader() 601 */ 602 @TestTargetNew( 603 level = TestLevel.COMPLETE, 604 notes = "", 605 method = "getContextClassLoader", 606 args = {} 607 ) 608 public void test_getContextClassLoader() { 609 // Test for method java.lang.ClassLoader 610 // java.lang.Thread.getContextClassLoader() 611 Thread t = new Thread(); 612 assertNotNull(Thread.currentThread().getContextClassLoader()); 613 assertTrue("Incorrect class loader returned", 614 t.getContextClassLoader() == Thread.currentThread() 615 .getContextClassLoader()); 616 } 617 618 /** 619 * @tests java.lang.Thread#getName() 620 */ 621 @TestTargetNew( 622 level = TestLevel.COMPLETE, 623 notes = "", 624 method = "getName", 625 args = {} 626 ) 627 public void test_getName() { 628 // Test for method java.lang.String java.lang.Thread.getName() 629 st = new Thread(new SimpleThread(1), "SimpleThread6"); 630 assertEquals("Returned incorrect thread name", 631 "SimpleThread6", st.getName()); 632 st.start(); 633 } 634 635 /** 636 * @tests java.lang.Thread#getPriority() 637 */ 638 @TestTargetNew( 639 level = TestLevel.COMPLETE, 640 notes = "", 641 method = "getPriority", 642 args = {} 643 ) 644 public void test_getPriority() { 645 // Test for method int java.lang.Thread.getPriority() 646 st = new Thread(new SimpleThread(1)); 647 st.setPriority(Thread.MAX_PRIORITY); 648 assertTrue("Returned incorrect thread priority", 649 st.getPriority() == Thread.MAX_PRIORITY); 650 st.start(); 651 } 652 653 /** 654 * @tests java.lang.Thread#getThreadGroup() 655 */ 656 @TestTargetNew( 657 level = TestLevel.COMPLETE, 658 notes = "", 659 method = "getThreadGroup", 660 args = {} 661 ) 662 public void test_getThreadGroup() { 663 // Test for method java.lang.ThreadGroup 664 // java.lang.Thread.getThreadGroup() 665 ThreadGroup tg = new ThreadGroup("Test Group4"); 666 st = new Thread(tg, /* new SimpleThread(1), */ "SimpleThread8"); 667 assertTrue("Returned incorrect thread group", st.getThreadGroup() == tg); 668 st.start(); 669 try { 670 st.join(); 671 } catch (InterruptedException e) { 672 } 673 assertNull("group should be null", st.getThreadGroup()); 674 assertNotNull("toString() should not be null", st.toString()); 675 tg.destroy(); 676 677 final Object lock = new Object(); 678 Thread t = new Thread() { 679 @Override 680 public void run() { 681 synchronized (lock) { 682 lock.notifyAll(); 683 } 684 } 685 }; 686 synchronized (lock) { 687 t.start(); 688 try { 689 lock.wait(); 690 } catch (InterruptedException e) { 691 } 692 } 693 int running = 0; 694 while (t.isAlive()) 695 running++; 696 ThreadGroup group = t.getThreadGroup(); 697 assertNull("ThreadGroup is not null", group); 698 } 699 700 /** 701 * @tests java.lang.Thread#interrupt() 702 */ 703 @TestTargetNew( 704 level = TestLevel.COMPLETE, 705 notes = "", 706 method = "interrupt", 707 args = {} 708 ) 709 public void test_interrupt() { 710 // Test for method void java.lang.Thread.interrupt() 711 final Object lock = new Object(); 712 class ChildThread1 extends Thread { 713 Thread parent; 714 715 boolean sync; 716 717 @Override 718 public void run() { 719 if (sync) { 720 synchronized (lock) { 721 lock.notify(); 722 try { 723 lock.wait(); 724 } catch (InterruptedException e) { 725 } 726 } 727 } 728 parent.interrupt(); 729 } 730 731 public ChildThread1(Thread p, String name, boolean sync) { 732 super(name); 733 parent = p; 734 this.sync = sync; 735 } 736 } 737 boolean interrupted = false; 738 try { 739 ct = new ChildThread1(Thread.currentThread(), "Interrupt Test1", 740 false); 741 synchronized (lock) { 742 ct.start(); 743 lock.wait(); 744 } 745 } catch (InterruptedException e) { 746 interrupted = true; 747 } 748 assertTrue("Failed to Interrupt thread1", interrupted); 749 750 interrupted = false; 751 try { 752 ct = new ChildThread1(Thread.currentThread(), "Interrupt Test2", 753 true); 754 synchronized (lock) { 755 ct.start(); 756 lock.wait(); 757 lock.notify(); 758 } 759 Thread.sleep(20000); 760 } catch (InterruptedException e) { 761 interrupted = true; 762 } 763 assertTrue("Failed to Interrupt thread2", interrupted); 764 765 SecurityManager sm = new SecurityManager() { 766 767 public void checkPermission(Permission perm) { 768 } 769 770 public void checkAccess(Thread t) { 771 throw new SecurityException(); 772 } 773 }; 774 st = new Thread(); 775 SecurityManager oldSm = System.getSecurityManager(); 776 System.setSecurityManager(sm); 777 try { 778 st.interrupt(); 779 fail("Should throw SecurityException"); 780 } catch (SecurityException e) { 781 // expected 782 } finally { 783 System.setSecurityManager(oldSm); 784 } 785 } 786 787 /** 788 * @tests java.lang.Thread#interrupted() 789 */ 790 @TestTargetNew( 791 level = TestLevel.COMPLETE, 792 notes = "", 793 method = "interrupted", 794 args = {} 795 ) 796 public void test_interrupted() { 797 assertFalse("Interrupted returned true for non-interrupted thread", Thread 798 .interrupted()); 799 Thread.currentThread().interrupt(); 800 assertTrue("Interrupted returned true for non-interrupted thread", Thread.interrupted()); 801 assertFalse("Failed to clear interrupted flag", Thread.interrupted()); 802 } 803 804 /** 805 * @tests java.lang.Thread#isAlive() 806 */ 807 @TestTargetNew( 808 level = TestLevel.COMPLETE, 809 notes = "", 810 method = "isAlive", 811 args = {} 812 ) 813 public void test_isAlive() { 814 // Test for method boolean java.lang.Thread.isAlive() 815 SimpleThread simple; 816 st = new Thread(simple = new SimpleThread(500)); 817 assertFalse("A thread that wasn't started is alive.", st.isAlive()); 818 synchronized (simple) { 819 st.start(); 820 try { 821 simple.wait(); 822 } catch (InterruptedException e) { 823 } 824 } 825 assertTrue("Started thread returned false", st.isAlive()); 826 827 try { 828 st.join(); 829 } catch (InterruptedException e) { 830 fail("Thread did not die"); 831 } 832 assertTrue("Stopped thread returned true", !st.isAlive()); 833 } 834 835 /** 836 * @tests java.lang.Thread#isDaemon() 837 */ 838 @TestTargetNew( 839 level = TestLevel.COMPLETE, 840 notes = "", 841 method = "isDaemon", 842 args = {} 843 ) 844 public void test_isDaemon() { 845 // Test for method boolean java.lang.Thread.isDaemon() 846 st = new Thread(new SimpleThread(1), "SimpleThread10"); 847 assertTrue("Non-Daemon thread returned true", !st.isDaemon()); 848 st.setDaemon(true); 849 assertTrue("Daemon thread returned false", st.isDaemon()); 850 st.start(); 851 } 852 853 /** 854 * @tests java.lang.Thread#isInterrupted() 855 */ 856 @TestTargetNew( 857 level = TestLevel.COMPLETE, 858 notes = "", 859 method = "isInterrupted", 860 args = {} 861 ) 862 public void test_isInterrupted() { 863 // Test for method boolean java.lang.Thread.isInterrupted() 864 class SpinThread implements Runnable { 865 public volatile boolean done = false; 866 867 public void run() { 868 while (!Thread.currentThread().isInterrupted()) 869 ; 870 while (!done) 871 ; 872 } 873 } 874 875 SpinThread spin = new SpinThread(); 876 spinner = new Thread(spin); 877 spinner.start(); 878 Thread.yield(); 879 try { 880 assertTrue("Non-Interrupted thread returned true", !spinner 881 .isInterrupted()); 882 spinner.interrupt(); 883 assertTrue("Interrupted thread returned false", spinner 884 .isInterrupted()); 885 spin.done = true; 886 } finally { 887 spinner.interrupt(); 888 spin.done = true; 889 } 890 } 891 892 /** 893 * @tests java.lang.Thread#join() 894 */ 895 @TestTargetNew( 896 level = TestLevel.COMPLETE, 897 notes = "", 898 method = "join", 899 args = {} 900 ) 901 public void test_join() { 902 // Test for method void java.lang.Thread.join() 903 SimpleThread simple; 904 try { 905 st = new Thread(simple = new SimpleThread(100)); 906 // cause isAlive() to be compiled by the JIT, as it must be called 907 // within 100ms below. 908 assertTrue("Thread is alive", !st.isAlive()); 909 synchronized (simple) { 910 st.start(); 911 simple.wait(); 912 } 913 st.join(); 914 } catch (InterruptedException e) { 915 fail("Join failed "); 916 } 917 assertFalse("Joined thread is still alive", st.isAlive()); 918 boolean result = true; 919 Thread th = new Thread("test"); 920 try { 921 th.join(); 922 } catch (InterruptedException e) { 923 result = false; 924 } 925 assertTrue("Hung joining a non-started thread", result); 926 th.start(); 927 928 st = new Thread() { 929 public void run() { 930 try { 931 join(); 932 fail("InterruptedException was not thrown."); 933 } catch(InterruptedException ie) { 934 //expected 935 } 936 } 937 }; 938 939 st.start(); 940 } 941 942 @TestTargetNew( 943 level = TestLevel.PARTIAL_COMPLETE, 944 notes = "Regression test for when join() failed due to spurious wakeups", 945 method = "join", 946 args = {long.class, int.class} 947 ) 948 public void test_joinWithSpuriousInterruption() throws InterruptedException { 949 final Thread parker = new Thread() { 950 @Override 951 public void run() { 952 for (int i = 0; i < 10; i++) { 953 // we used to get spurious wakeups upon unparking 954 LockSupport.park(); 955 } 956 } 957 }; 958 Thread unparker = new Thread() { 959 @Override 960 public void run() { 961 for (int i = 0; i < 10; i++) { 962 try { 963 Thread.sleep(100); 964 LockSupport.unpark(parker); 965 } catch (InterruptedException ignored) { 966 } 967 } 968 } 969 }; 970 971 long startNanos = System.nanoTime(); 972 parker.start(); 973 unparker.start(); 974 parker.join(500, 500000); 975 long netWaitTime = System.nanoTime() - startNanos; 976 assertTrue("Expected to wait at least 500000000ns, but was " + netWaitTime + "ns", 977 netWaitTime > 500000000); 978 } 979 980 /** 981 * @tests java.lang.Thread#join(long) 982 */ 983 @TestTargetNew( 984 level = TestLevel.COMPLETE, 985 notes = "", 986 method = "join", 987 args = {long.class} 988 ) 989 public void test_joinJ() { 990 // Test for method void java.lang.Thread.join(long) 991 SimpleThread simple; 992 try { 993 st = new Thread(simple = new SimpleThread(1000), "SimpleThread12"); 994 // cause isAlive() to be compiled by the JIT, as it must be called 995 // within 100ms below. 996 assertTrue("Thread is alive", !st.isAlive()); 997 synchronized (simple) { 998 st.start(); 999 simple.wait(); 1000 } 1001 st.join(10); 1002 } catch (InterruptedException e) { 1003 fail("Join failed "); 1004 } 1005 assertTrue("Join failed to timeout", st.isAlive()); 1006 1007 st.interrupt(); 1008 try { 1009 st = new Thread(simple = new SimpleThread(100), "SimpleThread13"); 1010 synchronized (simple) { 1011 st.start(); 1012 simple.wait(); 1013 } 1014 st.join(1000); 1015 } catch (InterruptedException e) { 1016 fail("Join failed : " + e.getMessage()); 1017 return; 1018 } 1019 assertTrue("Joined thread is still alive", !st.isAlive()); 1020 1021 final Object lock = new Object(); 1022 final Thread main = Thread.currentThread(); 1023 Thread killer = new Thread(new Runnable() { 1024 public void run() { 1025 try { 1026 synchronized (lock) { 1027 lock.notify(); 1028 } 1029 Thread.sleep(100); 1030 } catch (InterruptedException e) { 1031 return; 1032 } 1033 main.interrupt(); 1034 } 1035 }); 1036 boolean result = true; 1037 Thread th = new Thread("test"); 1038 try { 1039 synchronized (lock) { 1040 killer.start(); 1041 lock.wait(); 1042 } 1043 th.join(200); 1044 } catch (InterruptedException e) { 1045 result = false; 1046 } 1047 killer.interrupt(); 1048 assertTrue("Hung joining a non-started thread", result); 1049 th.start(); 1050 1051 st = new Thread() { 1052 public void run() { 1053 try { 1054 join(1000); 1055 fail("InterruptedException was not thrown."); 1056 } catch(InterruptedException ie) { 1057 //expected 1058 } 1059 } 1060 }; 1061 1062 st.start(); 1063 } 1064 1065 /** 1066 * @tests java.lang.Thread#join(long, int) 1067 */ 1068 @TestTargetNew( 1069 level = TestLevel.COMPLETE, 1070 notes = "", 1071 method = "join", 1072 args = {long.class, int.class} 1073 ) 1074 public void test_joinJI() { 1075 // Test for method void java.lang.Thread.join(long, int) 1076 SimpleThread simple; 1077 try { 1078 st = new Thread(simple = new SimpleThread(1000), "Squawk1"); 1079 assertTrue("Thread is alive", !st.isAlive()); 1080 synchronized (simple) { 1081 st.start(); 1082 simple.wait(); 1083 } 1084 1085 long firstRead = System.currentTimeMillis(); 1086 st.join(100, 999999); 1087 long secondRead = System.currentTimeMillis(); 1088 assertTrue("Did not join by appropriate time: " + secondRead + "-" 1089 + firstRead + "=" + (secondRead - firstRead), secondRead 1090 - firstRead <= 300); 1091 assertTrue("Joined thread is not alive", st.isAlive()); 1092 st.interrupt(); 1093 } catch (Exception e) { 1094 fail("Exception during test : " + e.getMessage()); 1095 } 1096 1097 final Object lock = new Object(); 1098 final Thread main = Thread.currentThread(); 1099 Thread killer = new Thread(new Runnable() { 1100 public void run() { 1101 try { 1102 synchronized (lock) { 1103 lock.notify(); 1104 } 1105 Thread.sleep(100); 1106 } catch (InterruptedException e) { 1107 return; 1108 } 1109 main.interrupt(); 1110 } 1111 }); 1112 boolean result = true; 1113 Thread th = new Thread("test"); 1114 try { 1115 synchronized (lock) { 1116 killer.start(); 1117 lock.wait(); 1118 } 1119 th.join(200, 20); 1120 } catch (InterruptedException e) { 1121 result = false; 1122 } 1123 killer.interrupt(); 1124 assertTrue("Hung joining a non-started thread", result); 1125 th.start(); 1126 1127 st = new Thread() { 1128 public void run() { 1129 try { 1130 join(1000, 20); 1131 fail("InterruptedException was not thrown."); 1132 } catch(InterruptedException ie) { 1133 //expected 1134 } 1135 } 1136 }; 1137 1138 st.start(); 1139 } 1140 1141 @TestTargets({ 1142 @TestTargetNew( 1143 level = TestLevel.COMPLETE, 1144 notes = "", 1145 method = "setContextClassLoader", 1146 args = {java.lang.ClassLoader.class} 1147 ), 1148 @TestTargetNew( 1149 level = TestLevel.COMPLETE, 1150 notes = "", 1151 method = "getContextClassLoader", 1152 args = {} 1153 ) 1154 }) 1155 public void test_setContextClassLoader() { 1156 PublicClassLoader pcl = new PublicClassLoader(); 1157 st = new Thread(); 1158 st.setContextClassLoader(pcl); 1159 assertEquals(pcl, st.getContextClassLoader()); 1160 1161 st.setContextClassLoader(null); 1162 assertNull(st.getContextClassLoader()); 1163 1164 SecurityManager sm = new SecurityManager() { 1165 public void checkPermission(Permission perm) { 1166 if (perm.getName().equals("setContextClassLoader") 1167 || perm.getName().equals("getClassLoader") ) { 1168 throw new SecurityException(); 1169 } 1170 } 1171 }; 1172 1173 SecurityManager oldSm = System.getSecurityManager(); 1174 System.setSecurityManager(sm); 1175 try { 1176 st.setContextClassLoader(pcl); 1177 fail("Should throw SecurityException"); 1178 } catch (SecurityException e) { 1179 // expected 1180 } finally { 1181 System.setSecurityManager(oldSm); 1182 } 1183 } 1184 1185 private Thread launchFiveSecondDummyThread() { 1186 Thread thread = new Thread() { 1187 public void run() { 1188 try { 1189 Thread.sleep(5000); 1190 } catch (InterruptedException e) { 1191 // Ignore 1192 } 1193 } 1194 }; 1195 1196 thread.start(); 1197 1198 return thread; 1199 } 1200 1201 private class ThreadSecurityManager extends SecurityManager { 1202 public void checkPermission(Permission perm) { 1203 } 1204 1205 public void checkAccess(Thread t) { 1206 throw new SecurityException(); 1207 } 1208 }; 1209 1210 /** 1211 * @tests java.lang.Thread#resume() 1212 */ 1213 @TestTargetNew( 1214 level = TestLevel.COMPLETE, 1215 notes = "", 1216 method = "resume", 1217 args = {} 1218 ) 1219 @AndroidOnly("RI does implement this method, whereas Android does not") 1220 @SuppressWarnings("deprecation") 1221 public void test_resume() { 1222 Thread thread = launchFiveSecondDummyThread(); 1223 1224 try { 1225 Thread.sleep(1000); 1226 } catch (InterruptedException e) { 1227 // Ignore 1228 } 1229 1230 // No-op in Android. Must neither have an effect nor throw an exception. 1231 Thread.State state = thread.getState(); 1232 thread.resume(); 1233 assertEquals(state, thread.getState()); 1234 1235 // Security checks are made even though method is not supported. 1236 SecurityManager oldSm = System.getSecurityManager(); 1237 System.setSecurityManager(new ThreadSecurityManager()); 1238 try { 1239 thread.resume(); 1240 fail("Should throw SecurityException"); 1241 } catch (SecurityException e) { 1242 // expected 1243 } finally { 1244 System.setSecurityManager(oldSm); 1245 } 1246 1247 try { 1248 thread.join(); 1249 } catch (InterruptedException e) { 1250 // Ignore 1251 } 1252 } 1253 1254 /** 1255 * @tests java.lang.Thread#run() 1256 */ 1257 @TestTargetNew( 1258 level = TestLevel.COMPLETE, 1259 notes = "", 1260 method = "run", 1261 args = {} 1262 ) 1263 public void test_run() { 1264 // Test for method void java.lang.Thread.run() 1265 class RunThread implements Runnable { 1266 boolean didThreadRun = false; 1267 1268 public void run() { 1269 didThreadRun = true; 1270 } 1271 } 1272 RunThread rt = new RunThread(); 1273 Thread t = new Thread(rt); 1274 try { 1275 t.start(); 1276 int count = 0; 1277 while (!rt.didThreadRun && count < 20) { 1278 Thread.sleep(100); 1279 count++; 1280 } 1281 assertTrue("Thread did not run", rt.didThreadRun); 1282 t.join(); 1283 } catch (InterruptedException e) { 1284 assertTrue("Joined thread was interrupted", true); 1285 } 1286 assertTrue("Joined thread is still alive", !t.isAlive()); 1287 } 1288 1289 /** 1290 * @tests java.lang.Thread#setDaemon(boolean) 1291 */ 1292 @TestTargetNew( 1293 level = TestLevel.COMPLETE, 1294 notes = "", 1295 method = "setDaemon", 1296 args = {boolean.class} 1297 ) 1298 public void test_setDaemonZ() { 1299 // Test for method void java.lang.Thread.setDaemon(boolean) 1300 st = new Thread(new SimpleThread(1), "SimpleThread14"); 1301 st.setDaemon(true); 1302 assertTrue("Failed to set thread as daemon thread", st.isDaemon()); 1303 st.start(); 1304 1305 // BEGIN android-added 1306 st = new Thread(new SimpleThread(5)); 1307 st.start(); 1308 try { 1309 st.setDaemon(false); 1310 fail("setDaemon() must throw exception for started thread"); 1311 } catch (IllegalThreadStateException ex) { 1312 // We expect this one. 1313 } 1314 // END android-added 1315 1316 SecurityManager sm = new SecurityManager() { 1317 1318 public void checkPermission(Permission perm) { 1319 } 1320 1321 public void checkAccess(Thread t) { 1322 throw new SecurityException(); 1323 } 1324 }; 1325 1326 SecurityManager oldSm = System.getSecurityManager(); 1327 System.setSecurityManager(sm); 1328 try { 1329 st.setDaemon(false); 1330 fail("Should throw SecurityException"); 1331 } catch (SecurityException e) { 1332 // expected 1333 } finally { 1334 System.setSecurityManager(oldSm); 1335 } 1336 } 1337 1338 /** 1339 * @tests java.lang.Thread#setName(java.lang.String) 1340 */ 1341 @TestTargetNew( 1342 level = TestLevel.COMPLETE, 1343 notes = "", 1344 method = "setName", 1345 args = {java.lang.String.class} 1346 ) 1347 public void test_setNameLjava_lang_String() { 1348 // Test for method void java.lang.Thread.setName(java.lang.String) 1349 st = new Thread(new SimpleThread(1), "SimpleThread15"); 1350 st.setName("Bogus Name"); 1351 assertEquals("Failed to set thread name", 1352 "Bogus Name", st.getName()); 1353 try { 1354 st.setName(null); 1355 fail("Null should not be accepted as a valid name"); 1356 } catch (NullPointerException e) { 1357 // success 1358 assertTrue("Null should not be accepted as a valid name", true); 1359 } 1360 st.start(); 1361 1362 SecurityManager sm = new SecurityManager() { 1363 1364 public void checkPermission(Permission perm) { 1365 } 1366 1367 public void checkAccess(Thread t) { 1368 throw new SecurityException(); 1369 } 1370 }; 1371 1372 SecurityManager oldSm = System.getSecurityManager(); 1373 System.setSecurityManager(sm); 1374 try { 1375 st.setName("Bogus Name"); 1376 fail("Should throw SecurityException"); 1377 } catch (SecurityException e) { 1378 // expected 1379 } finally { 1380 System.setSecurityManager(oldSm); 1381 } 1382 } 1383 1384 /** 1385 * @tests java.lang.Thread#setPriority(int) 1386 */ 1387 @TestTargetNew( 1388 level = TestLevel.COMPLETE, 1389 notes = "", 1390 method = "setPriority", 1391 args = {int.class} 1392 ) 1393 public void test_setPriorityI() { 1394 // Test for method void java.lang.Thread.setPriority(int) 1395 st = new Thread(new SimpleThread(1)); 1396 st.setPriority(Thread.MAX_PRIORITY); 1397 assertTrue("Failed to set priority", 1398 st.getPriority() == Thread.MAX_PRIORITY); 1399 st.start(); 1400 1401 SecurityManager sm = new SecurityManager() { 1402 1403 public void checkPermission(Permission perm) { 1404 } 1405 1406 public void checkAccess(Thread t) { 1407 throw new SecurityException(); 1408 } 1409 }; 1410 1411 SecurityManager oldSm = System.getSecurityManager(); 1412 System.setSecurityManager(sm); 1413 try { 1414 st.setPriority(Thread.MIN_PRIORITY); 1415 fail("Should throw SecurityException"); 1416 } catch (SecurityException e) { 1417 // expected 1418 } finally { 1419 System.setSecurityManager(oldSm); 1420 } 1421 1422 try { 1423 st.setPriority(Thread.MIN_PRIORITY - 1); 1424 fail("IllegalArgumentException is not thrown."); 1425 } catch(IllegalArgumentException iae) { 1426 //expected 1427 } 1428 1429 try { 1430 st.setPriority(Thread.MAX_PRIORITY + 1); 1431 fail("IllegalArgumentException is not thrown."); 1432 } catch(IllegalArgumentException iae) { 1433 //expected 1434 } 1435 } 1436 1437 /** 1438 * @tests java.lang.Thread#sleep(long) 1439 */ 1440 @TestTargetNew( 1441 level = TestLevel.COMPLETE, 1442 notes = "", 1443 method = "sleep", 1444 args = {long.class} 1445 ) 1446 public void test_sleepJ() { 1447 // Note: Not too much we can test here that can be reliably measured. 1448 1449 // Check that basic behavior is about right (with some tolerance) 1450 long stime = System.currentTimeMillis(); 1451 1452 try { 1453 Thread.sleep(1000); 1454 } catch (InterruptedException e) { 1455 fail("Unexpected InterruptedException was thrown"); 1456 } 1457 1458 long ftime = System.currentTimeMillis(); 1459 1460 assertTrue("Failed to sleep long enough", (ftime - stime) >= 500); 1461 assertTrue("Failed to wake up early enough", (ftime - stime) <= 1500); 1462 1463 // Check that interrupt works 1464 st = new Thread() { 1465 public void run() { 1466 try { 1467 sleep(10000); 1468 } catch(InterruptedException ie) { 1469 wasInterrupted = true; 1470 } 1471 } 1472 }; 1473 1474 st.start(); 1475 1476 try { 1477 Thread.sleep(5000); 1478 } catch(InterruptedException e) { 1479 fail("Unexpected InterruptedException was thrown"); 1480 } 1481 1482 st.interrupt(); 1483 1484 try { 1485 Thread.sleep(5000); 1486 } catch(InterruptedException e) { 1487 fail("Unexpected InterruptedException was thrown"); 1488 } 1489 1490 assertTrue(wasInterrupted); 1491 } 1492 1493 /** 1494 * @tests java.lang.Thread#sleep(long, int) 1495 */ 1496 @TestTargetNew( 1497 level = TestLevel.COMPLETE, 1498 notes = "", 1499 method = "sleep", 1500 args = {long.class, int.class} 1501 ) 1502 public void test_sleepJI() { 1503 // Note: Not too much we can test here that can be reliably measured. 1504 1505 // Check that basic behavior is about right (with some tolerance) 1506 long stime = System.currentTimeMillis(); 1507 1508 try { 1509 Thread.sleep(1000, 99999); 1510 } catch (InterruptedException e) { 1511 fail("Unexpected InterruptedException was thrown"); 1512 } 1513 1514 long ftime = System.currentTimeMillis(); 1515 1516 assertTrue("Failed to sleep long enough", (ftime - stime) >= 500); 1517 assertTrue("Failed to wake up early enough", (ftime - stime) <= 1500); 1518 1519 // Check that interrupt works 1520 st = new Thread() { 1521 public void run() { 1522 try { 1523 sleep(10000, 99999); 1524 } catch(InterruptedException ie) { 1525 wasInterrupted = true; 1526 } 1527 } 1528 }; 1529 1530 st.start(); 1531 1532 try { 1533 Thread.sleep(5000, 99999); 1534 } catch(InterruptedException e) { 1535 fail("Unexpected InterruptedException was thrown"); 1536 } 1537 1538 st.interrupt(); 1539 1540 try { 1541 Thread.sleep(5000); 1542 } catch(InterruptedException e) { 1543 fail("Unexpected InterruptedException was thrown"); 1544 } 1545 1546 assertTrue(wasInterrupted); 1547 } 1548 1549 /** 1550 * @tests java.lang.Thread#start() 1551 */ 1552 @TestTargetNew( 1553 level = TestLevel.COMPLETE, 1554 notes = "", 1555 method = "start", 1556 args = {} 1557 ) 1558 public void test_start() { 1559 // Test for method void java.lang.Thread.start() 1560 try { 1561 ResSupThread t = new ResSupThread(Thread.currentThread()); 1562 synchronized (t) { 1563 ct = new Thread(t, "Interrupt Test4"); 1564 ct.start(); 1565 t.wait(); 1566 } 1567 assertTrue("Thread is not running1", ct.isAlive()); 1568 // Let the child thread get going. 1569 int orgval = t.getCheckVal(); 1570 Thread.sleep(150); 1571 assertTrue("Thread is not running2", orgval != t.getCheckVal()); 1572 ct.interrupt(); 1573 } catch (InterruptedException e) { 1574 fail("Unexpected interrupt occurred"); 1575 } 1576 Thread thr = new Thread(); 1577 thr.start(); 1578 try { 1579 thr.start(); 1580 } catch(IllegalThreadStateException itse){ 1581 //expected 1582 } 1583 } 1584 1585 /** 1586 * @tests java.lang.Thread#stop() 1587 */ 1588 @TestTargetNew( 1589 level = TestLevel.COMPLETE, 1590 notes = "", 1591 method = "stop", 1592 args = {} 1593 ) 1594 @AndroidOnly("RI does implement this method, whereas Android does not") 1595 @SuppressWarnings("deprecation") 1596 public void test_stop() { 1597 Thread thread = launchFiveSecondDummyThread(); 1598 1599 try { 1600 Thread.sleep(1000); 1601 } catch (InterruptedException e) { 1602 // Ignore 1603 } 1604 1605 // No-op in Android. Must neither have an effect nor throw an exception. 1606 Thread.State state = thread.getState(); 1607 thread.stop(); 1608 assertEquals(state, thread.getState()); 1609 1610 // Security checks are made even though method is not supported. 1611 SecurityManager oldSm = System.getSecurityManager(); 1612 System.setSecurityManager(new ThreadSecurityManager()); 1613 try { 1614 thread.stop(); 1615 fail("Should throw SecurityException"); 1616 } catch (SecurityException e) { 1617 // expected 1618 } finally { 1619 System.setSecurityManager(oldSm); 1620 } 1621 1622 try { 1623 thread.join(); 1624 } catch (InterruptedException e) { 1625 // Ignore 1626 } 1627 } 1628 1629 /** 1630 * @tests java.lang.Thread#stop(java.lang.Throwable) 1631 */ 1632 @TestTargetNew( 1633 level = TestLevel.COMPLETE, 1634 notes = "Verifies security.", 1635 method = "stop", 1636 args = {java.lang.Throwable.class} 1637 ) 1638 @SuppressWarnings("deprecation") 1639 public void test_stopLjava_lang_Throwable_subtest0() { 1640 Thread thread = new Thread() { 1641 public void run() { 1642 try { 1643 Thread.sleep(5000); 1644 } catch (InterruptedException e) { 1645 // Ignore 1646 } 1647 } 1648 }; 1649 1650 thread.start(); 1651 try { 1652 Thread.sleep(1000); 1653 } catch (InterruptedException e) { 1654 // Ignore 1655 } 1656 1657 // No-op in Android. Must neither have an effect nor throw an exception. 1658 Thread.State state = thread.getState(); 1659 thread.stop(new Exception("Oops!")); 1660 assertEquals(state, thread.getState()); 1661 1662 // Security checks are made even though method is not supported. 1663 SecurityManager sm = new SecurityManager() { 1664 public void checkPermission(Permission perm) { 1665 } 1666 1667 public void checkAccess(Thread t) { 1668 throw new SecurityException(); 1669 } 1670 }; 1671 1672 SecurityManager oldSm = System.getSecurityManager(); 1673 System.setSecurityManager(sm); 1674 try { 1675 thread.stop(); 1676 fail("Should throw SecurityException"); 1677 } catch (SecurityException e) { 1678 // expected 1679 } finally { 1680 System.setSecurityManager(oldSm); 1681 } 1682 1683 try { 1684 thread.join(); 1685 } catch (InterruptedException e) { 1686 // Ignore 1687 } 1688 } 1689 1690 /** 1691 * @tests java.lang.Thread#suspend() 1692 */ 1693 @TestTargetNew( 1694 level = TestLevel.COMPLETE, 1695 notes = "", 1696 method = "suspend", 1697 args = {} 1698 ) 1699 @AndroidOnly("RI does implement this method, whereas Android does not") 1700 @SuppressWarnings("deprecation") 1701 public void test_suspend() { 1702 Thread thread = launchFiveSecondDummyThread(); 1703 1704 try { 1705 Thread.sleep(1000); 1706 } catch (InterruptedException e) { 1707 // Ignore 1708 } 1709 1710 // No-op in Android. Must neither have an effect nor throw an exception. 1711 Thread.State state = thread.getState(); 1712 thread.suspend(); 1713 assertEquals(state, thread.getState()); 1714 1715 // Security checks are made even though method is not supported. 1716 SecurityManager oldSm = System.getSecurityManager(); 1717 System.setSecurityManager(new ThreadSecurityManager()); 1718 try { 1719 thread.suspend(); 1720 fail("Should throw SecurityException"); 1721 } catch (SecurityException e) { 1722 // expected 1723 } finally { 1724 System.setSecurityManager(oldSm); 1725 } 1726 1727 try { 1728 thread.join(); 1729 } catch (InterruptedException e) { 1730 // Ignore 1731 } 1732 } 1733 1734 /** 1735 * @tests java.lang.Thread#toString() 1736 */ 1737 @TestTargetNew( 1738 level = TestLevel.COMPLETE, 1739 notes = "", 1740 method = "toString", 1741 args = {} 1742 ) 1743 public void test_toString() { 1744 // Test for method java.lang.String java.lang.Thread.toString() 1745 ThreadGroup tg = new ThreadGroup("Test Group5"); 1746 st = new Thread(tg, new SimpleThread(1), "SimpleThread17"); 1747 final String stString = st.toString(); 1748 final String expected = "Thread[SimpleThread17,5,Test Group5]"; 1749 assertTrue("Returned incorrect string: " + stString + "\t(expecting :" 1750 + expected + ")", stString.equals(expected)); 1751 st.start(); 1752 try { 1753 st.join(); 1754 } catch (InterruptedException e) { 1755 } 1756 tg.destroy(); 1757 } 1758 1759 @TestTargetNew( 1760 level = TestLevel.COMPLETE, 1761 notes = "", 1762 method = "yield", 1763 args = {} 1764 ) 1765 public void test_yield() { 1766 1767 Counter [] countersNotYeld = new Counter[10]; 1768 1769 for(int i = 0; i < 10; i++) { 1770 countersNotYeld[i] = new Counter(false); 1771 } 1772 Counter countersYeld = new Counter(true); 1773 try { 1774 Thread.sleep(11000); 1775 } catch(InterruptedException ie) {} 1776 1777 for(Counter c:countersNotYeld) { 1778 assertTrue(countersYeld.counter == c.counter); 1779 } 1780 } 1781 1782 class Counter extends Thread { 1783 public int counter = 0; 1784 boolean isDoYield = false; 1785 1786 public Counter(boolean isDoYield) { 1787 this.isDoYield = isDoYield; 1788 start(); 1789 } 1790 1791 public void run() { 1792 for(int i = 0; i < 10000; i++) { 1793 if(isDoYield) 1794 yield(); 1795 counter ++; 1796 } 1797 } 1798 } 1799 1800 1801 /** 1802 * @tests java.lang.Thread#getAllStackTraces() 1803 */ 1804 @TestTargetNew( 1805 level = TestLevel.COMPLETE, 1806 notes = "", 1807 method = "getAllStackTraces", 1808 args = {} 1809 ) 1810 public void test_getAllStackTraces() { 1811 Map<Thread, StackTraceElement[]> stMap = Thread.getAllStackTraces(); 1812 assertNotNull(stMap); 1813 //TODO add security-based tests 1814 1815 SecurityManager sm = new SecurityManager() { 1816 1817 public void checkPermission(Permission perm) { 1818 if(perm.getName().equals("modifyThreadGroup")) { 1819 throw new SecurityException(); 1820 } 1821 } 1822 }; 1823 1824 SecurityManager oldSm = System.getSecurityManager(); 1825 System.setSecurityManager(sm); 1826 try { 1827 Thread.getAllStackTraces(); 1828 fail("Should throw SecurityException"); 1829 } catch (SecurityException e) { 1830 // expected 1831 } finally { 1832 System.setSecurityManager(oldSm); 1833 } 1834 } 1835 1836 /** 1837 * @tests java.lang.Thread#getDefaultUncaughtExceptionHandler 1838 * @tests java.lang.Thread#setDefaultUncaughtExceptionHandler 1839 */ 1840 @TestTargets({ 1841 @TestTargetNew( 1842 level = TestLevel.COMPLETE, 1843 notes = "", 1844 method = "setDefaultUncaughtExceptionHandler", 1845 args = {java.lang.Thread.UncaughtExceptionHandler.class} 1846 ), 1847 @TestTargetNew( 1848 level = TestLevel.COMPLETE, 1849 notes = "", 1850 method = "getDefaultUncaughtExceptionHandler", 1851 args = {} 1852 ) 1853 }) 1854 public void test_get_setDefaultUncaughtExceptionHandler() { 1855 class Handler implements UncaughtExceptionHandler { 1856 public void uncaughtException(Thread thread, Throwable ex) { 1857 } 1858 } 1859 1860 final Handler handler = new Handler(); 1861 Thread.setDefaultUncaughtExceptionHandler(handler); 1862 assertSame(handler, Thread.getDefaultUncaughtExceptionHandler()); 1863 1864 Thread.setDefaultUncaughtExceptionHandler(null); 1865 assertNull(Thread.getDefaultUncaughtExceptionHandler()); 1866 //TODO add security-based tests 1867 1868 SecurityManager sm = new SecurityManager() { 1869 1870 public void checkPermission(Permission perm) { 1871 if(perm.getName(). 1872 equals("setDefaultUncaughtExceptionHandler")) { 1873 throw new SecurityException(); 1874 } 1875 } 1876 }; 1877 1878 SecurityManager oldSm = System.getSecurityManager(); 1879 System.setSecurityManager(sm); 1880 try { 1881 st.setDefaultUncaughtExceptionHandler(handler); 1882 fail("Should throw SecurityException"); 1883 } catch (SecurityException e) { 1884 // expected 1885 } finally { 1886 System.setSecurityManager(oldSm); 1887 } 1888 } 1889 1890 /** 1891 * @tests java.lang.Thread#getStackTrace() 1892 */ 1893 @TestTargetNew( 1894 level = TestLevel.COMPLETE, 1895 notes = "", 1896 method = "getStackTrace", 1897 args = {} 1898 ) 1899 public void test_getStackTrace() { 1900 StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace(); 1901 1902 assertNotNull(stackTrace); 1903 1904 stack_trace_loop: { 1905 for (int i = 0; i < stackTrace.length; i++) { 1906 StackTraceElement e = stackTrace[i]; 1907 if (getClass().getName().equals(e.getClassName())) { 1908 if ("test_getStackTrace".equals(e.getMethodName())) { 1909 break stack_trace_loop; 1910 } 1911 } 1912 } 1913 fail("class and method not found in stack trace"); 1914 } 1915 1916 //TODO add security-based tests 1917 1918 SecurityManager sm = new SecurityManager() { 1919 1920 public void checkPermission(Permission perm) { 1921 if(perm.getName(). 1922 equals("getStackTrace")) { 1923 throw new SecurityException(); 1924 } 1925 } 1926 }; 1927 st = new Thread(); 1928 SecurityManager oldSm = System.getSecurityManager(); 1929 System.setSecurityManager(sm); 1930 try { 1931 st.getStackTrace(); 1932 fail("Should throw SecurityException"); 1933 } catch (SecurityException e) { 1934 // expected 1935 } finally { 1936 System.setSecurityManager(oldSm); 1937 } 1938 } 1939 1940 /** 1941 * @tests java.lang.Thread#getState() 1942 */ 1943 @TestTargetNew( 1944 level = TestLevel.COMPLETE, 1945 notes = "", 1946 method = "getState", 1947 args = {} 1948 ) 1949 public void test_getState() { 1950 Thread.State state = Thread.currentThread().getState(); 1951 assertNotNull(state); 1952 assertEquals(Thread.State.RUNNABLE, state); 1953 1954 final Semaphore sem = new Semaphore(0); 1955 final Object lock = new Object(); 1956 Thread th = new Thread() { 1957 @Override 1958 public void run() { 1959 while (!sem.hasQueuedThreads()) {} 1960 sem.release(); 1961 1962 // RUNNABLE 1963 while (run) {} 1964 1965 try { 1966 // WAITING 1967 sem.acquire(); 1968 } catch (InterruptedException e) { 1969 fail("InterruptedException was thrown."); 1970 } 1971 1972 // BLOCKED 1973 synchronized (lock) { 1974 lock.equals(new Object()); 1975 } 1976 synchronized (lock) { 1977 try { 1978 sem.release(); 1979 1980 // TIMED_WAITING 1981 lock.wait(Long.MAX_VALUE); 1982 } catch (InterruptedException e) { 1983 // expected 1984 } 1985 } 1986 1987 // TERMINATED upon return 1988 } 1989 }; 1990 assertEquals(Thread.State.NEW, th.getState()); 1991 th.start(); 1992 try { 1993 sem.acquire(); 1994 } catch (InterruptedException e) { 1995 fail("InterruptedException was thrown."); 1996 } 1997 assertEquals(Thread.State.RUNNABLE, th.getState()); 1998 run = false; 1999 2000 while (!sem.hasQueuedThreads()){} 2001 2002 assertEquals(Thread.State.WAITING, th.getState()); 2003 synchronized (lock) { 2004 sem.release(); 2005 long start = System.currentTimeMillis(); 2006 while(start + 1000 > System.currentTimeMillis()) {} 2007 assertEquals(Thread.State.BLOCKED, th.getState()); 2008 } 2009 2010 try { 2011 sem.acquire(); 2012 } catch (InterruptedException e) { 2013 fail("InterruptedException was thrown."); 2014 } 2015 2016 synchronized (lock) { 2017 assertEquals(Thread.State.TIMED_WAITING, th.getState()); 2018 th.interrupt(); 2019 } 2020 2021 try { 2022 th.join(1000); 2023 } catch(InterruptedException ie) { 2024 fail("InterruptedException was thrown."); 2025 } 2026 assertEquals(Thread.State.TERMINATED, th.getState()); 2027 } 2028 volatile boolean run = true; 2029 2030 /** 2031 * @tests java.lang.Thread#getUncaughtExceptionHandler 2032 * @tests java.lang.Thread#setUncaughtExceptionHandler 2033 */ 2034 @TestTargets({ 2035 @TestTargetNew( 2036 level = TestLevel.COMPLETE, 2037 notes = "", 2038 method = "getUncaughtExceptionHandler", 2039 args = {} 2040 ), 2041 @TestTargetNew( 2042 level = TestLevel.COMPLETE, 2043 notes = "", 2044 method = "setUncaughtExceptionHandler", 2045 args = {java.lang.Thread.UncaughtExceptionHandler.class} 2046 ) 2047 }) 2048 public void test_get_setUncaughtExceptionHandler() { 2049 class Handler implements UncaughtExceptionHandler { 2050 public void uncaughtException(Thread thread, Throwable ex) { 2051 } 2052 } 2053 2054 final Handler handler = new Handler(); 2055 Thread.currentThread().setUncaughtExceptionHandler(handler); 2056 assertSame(handler, Thread.currentThread().getUncaughtExceptionHandler()); 2057 2058 Thread.currentThread().setUncaughtExceptionHandler(null); 2059 2060 //TODO add security-based tests 2061 SecurityManager sm = new SecurityManager() { 2062 2063 public void checkPermission(Permission perm) { 2064 } 2065 2066 public void checkAccess(Thread t) { 2067 throw new SecurityException(); 2068 } 2069 }; 2070 st = new Thread(); 2071 SecurityManager oldSm = System.getSecurityManager(); 2072 System.setSecurityManager(sm); 2073 try { 2074 st.setUncaughtExceptionHandler(handler); 2075 fail("Should throw SecurityException"); 2076 } catch (SecurityException e) { 2077 // expected 2078 } finally { 2079 System.setSecurityManager(oldSm); 2080 } 2081 2082 } 2083 2084 /** 2085 * @tests java.lang.Thread#getId() 2086 */ 2087 @TestTargetNew( 2088 level = TestLevel.COMPLETE, 2089 notes = "", 2090 method = "getId", 2091 args = {} 2092 ) 2093 public void test_getId() { 2094 assertTrue("current thread's ID is not positive", Thread.currentThread().getId() > 0); 2095 2096 //check all the current threads for positive IDs 2097 Map<Thread, StackTraceElement[]> stMap = Thread.getAllStackTraces(); 2098 for (Thread thread : stMap.keySet()) { 2099 assertTrue("thread's ID is not positive: " + thread.getName(), thread.getId() > 0); 2100 } 2101 } 2102 2103 /** 2104 * @tests java.lang.Thread#holdLock() 2105 */ 2106 @TestTargetNew( 2107 level = TestLevel.COMPLETE, 2108 notes = "", 2109 method = "holdsLock", 2110 args = {java.lang.Object.class} 2111 ) 2112 public void test_holdsLock() { 2113 MonitoredClass monitor = new MonitoredClass(); 2114 2115 monitor.enterLocked(); 2116 monitor.enterNonLocked(); 2117 2118 try { 2119 Thread.holdsLock(null); 2120 fail("NullPointerException was not thrown."); 2121 } catch(NullPointerException npe) { 2122 //expected 2123 } 2124 } 2125 2126 @Override 2127 protected void tearDown() { 2128 try { 2129 if (st != null) 2130 st.interrupt(); 2131 } catch (Exception e) { 2132 } 2133 try { 2134 if (spinner != null) 2135 spinner.interrupt(); 2136 } catch (Exception e) { 2137 } 2138 try { 2139 if (ct != null) 2140 ct.interrupt(); 2141 } catch (Exception e) { 2142 } 2143 2144 try { 2145 spinner = null; 2146 st = null; 2147 ct = null; 2148 System.runFinalization(); 2149 } catch (Exception e) { 2150 } 2151 } 2152 } 2153