java/lang/ThreadTest.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You 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 org.apache.harmony.luni.tests.java.lang;

import dalvik.annotation.TestInfo;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTarget;
import dalvik.annotation.TestTargetClass;

import java.lang.Thread.UncaughtExceptionHandler;
import java.security.Permission;
import java.util.Map;

@TestTargetClass(Thread.class)
public class ThreadTest extends junit.framework.TestCase {

    static class SimpleThread implements Runnable {
        int delay;

        public void run() {
            try {
                synchronized (this) {
                    this.notify();
                    this.wait(delay);
                }
            } catch (InterruptedException e) {
                return;
            }

        }

        public SimpleThread(int d) {
            if (d >= 0)
                delay = d;
        }
    }

    static class YieldThread implements Runnable {
        volatile int delay;

        public void run() {
            int x = 0;
            while (true) {
                ++x;
            }
        }

        public YieldThread(int d) {
            if (d >= 0)
                delay = d;
        }
    }

    static class ResSupThread implements Runnable {
        Thread parent;

        volatile int checkVal = -1;

        public void run() {
            try {
                synchronized (this) {
                    this.notify();
                }
                while (true) {
                    checkVal++;
                    zz();
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                return;
            } catch (BogusException e) {
                try {
                    // Give parent a chance to sleep
                    Thread.sleep(500);
                } catch (InterruptedException x) {
                }
                parent.interrupt();
                while (!Thread.currentThread().isInterrupted()) {
                    // Don't hog the CPU
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException x) {
                        // This is what we've been waiting for...don't throw it
                        // away!
                        break;
                    }
                }
            }
        }

        public void zz() throws BogusException {
        }

        public ResSupThread(Thread t) {
            parent = t;
        }

        public synchronized int getCheckVal() {
            return checkVal;
        }
    }

    static class BogusException extends Throwable {

        private static final long serialVersionUID = 1L;

        public BogusException(String s) {
            super(s);
        }
    }

    // TODO Added by Noser
    class MonitoredClass {
        public synchronized void enterLocked() {
            boolean b = Thread.holdsLock(this);
            assertTrue("Thread should hold lock for object", b);
        }

        public void enterNonLocked() {
            boolean b = Thread.holdsLock(this);
            assertFalse("Thread should not hold lock for object", b);
        }
    }

    Thread st, ct, spinner;

    static boolean calledMySecurityManager = false;

    /**
     * @tests java.lang.Thread#Thread()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "Thread",
          methodArgs = {}
        )
    })
    public void test_Constructor() {
        // Test for method java.lang.Thread()

        Thread t;
        SecurityManager m = new SecurityManager() {
            @Override
            public ThreadGroup getThreadGroup() {
                calledMySecurityManager = true;
                return Thread.currentThread().getThreadGroup();
            }

            @Override
            public void checkPermission(Permission permission) {
                if (permission.getName().equals("setSecurityManager")) {
                    return;
                }
                super.checkPermission(permission);
            }
        };
        try {
            // To see if it checks Thread creation with our SecurityManager
            System.setSecurityManager(m);
            t = new Thread();
        } finally {
            // restore original, no side-effects
            System.setSecurityManager(null);
        }
        assertTrue("Did not call SecurityManager.getThreadGroup ()",
                calledMySecurityManager);
        t.start();
    }

    /**
     * @tests java.lang.Thread#Thread(java.lang.Runnable)
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "Thread",
          methodArgs = {java.lang.Runnable.class}
        )
    })
    public void test_ConstructorLjava_lang_Runnable() {
        // Test for method java.lang.Thread(java.lang.Runnable)
        try {
            ct = new Thread(new SimpleThread(10));
            ct.start();
        } catch (Exception e) {
            fail("Failed to create subthread : " + e.getMessage());
        }
    }

    /**
     * @tests java.lang.Thread#Thread(java.lang.Runnable, java.lang.String)
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "Thread",
          methodArgs = {java.lang.Runnable.class, java.lang.String.class}
        )
    })
    public void test_ConstructorLjava_lang_RunnableLjava_lang_String() {
        // Test for method java.lang.Thread(java.lang.Runnable,
        // java.lang.String)
        Thread st1 = new Thread(new SimpleThread(1), "SimpleThread1");
        assertEquals("Constructed thread with incorrect thread name", "SimpleThread1", st1
                .getName());
        st1.start();
    }

    /**
     * @tests java.lang.Thread#Thread(java.lang.String)
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "Thread",
          methodArgs = {java.lang.String.class}
        )
    })
    public void test_ConstructorLjava_lang_String() {
        // Test for method java.lang.Thread(java.lang.String)
        Thread t = new Thread("Testing");
        assertEquals("Created tread with incorrect name",
                "Testing", t.getName());
        t.start();
    }

    /**
     * @tests java.lang.Thread#Thread(java.lang.ThreadGroup, java.lang.Runnable)
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "Thread",
          methodArgs = {java.lang.ThreadGroup.class, java.lang.Runnable.class}
        )
    })
    public void test_ConstructorLjava_lang_ThreadGroupLjava_lang_Runnable() {
        // Test for method java.lang.Thread(java.lang.ThreadGroup,
        // java.lang.Runnable)
        ThreadGroup tg = new ThreadGroup("Test Group1");
        st = new Thread(tg, new SimpleThread(1), "SimpleThread2");
        assertTrue("Returned incorrect thread group", st.getThreadGroup() == tg);
        st.start();
        try {
            st.join();
        } catch (InterruptedException e) {
        }
        tg.destroy();
    }

    /**
     * @tests java.lang.Thread#Thread(java.lang.ThreadGroup, java.lang.Runnable,
     *        java.lang.String)
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "Thread",
          methodArgs = {java.lang.ThreadGroup.class, java.lang.Runnable.class, java.lang.String.class}
        )
    })
    public void test_ConstructorLjava_lang_ThreadGroupLjava_lang_RunnableLjava_lang_String() {
        // Test for method java.lang.Thread(java.lang.ThreadGroup,
        // java.lang.Runnable, java.lang.String)
        ThreadGroup tg = new ThreadGroup("Test Group2");
        st = new Thread(tg, new SimpleThread(1), "SimpleThread3");
        assertTrue("Constructed incorrect thread", (st.getThreadGroup() == tg)
                && st.getName().equals("SimpleThread3"));
        st.start();
        try {
            st.join();
        } catch (InterruptedException e) {
        }
        tg.destroy();

        Runnable r = new Runnable() {
            public void run() {
            }
        };

        ThreadGroup foo = null;
        try {
            new Thread(foo = new ThreadGroup("foo"), r, null);
            // Should not get here
            fail("Null cannot be accepted as Thread name");
        } catch (NullPointerException npe) {
            assertTrue("Null cannot be accepted as Thread name", true);
            foo.destroy();
        }

    }

    /**
     * @tests java.lang.Thread#Thread(java.lang.ThreadGroup, java.lang.String)
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "Thread",
          methodArgs = {java.lang.ThreadGroup.class, java.lang.String.class}
        )
    })
    public void test_ConstructorLjava_lang_ThreadGroupLjava_lang_String() {
        // Test for method java.lang.Thread(java.lang.ThreadGroup,
        // java.lang.String)
        st = new Thread(new SimpleThread(1), "SimpleThread4");
        assertEquals("Returned incorrect thread name",
                "SimpleThread4", st.getName());
        st.start();
    }

    /**
     * @tests java.lang.Thread#activeCount()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "activeCount",
          methodArgs = {}
        )
    })
    public void test_activeCount() {
        // Test for method int java.lang.Thread.activeCount()
        Thread t = new Thread(new SimpleThread(1));
        int active = Thread.activeCount();
        assertTrue("Incorrect read made: " + active, active > 0);
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
        }
    }

    /**
     * @tests java.lang.Thread#checkAccess()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "checkAccess",
          methodArgs = {}
        )
    })
    public void test_checkAccess() {
        // Test for method void java.lang.Thread.checkAccess()
        ThreadGroup tg = new ThreadGroup("Test Group3");
        try {
            st = new Thread(tg, new SimpleThread(1), "SimpleThread5");
            st.checkAccess();
            assertTrue("CheckAccess passed", true);
        } catch (SecurityException e) {
            fail("CheckAccess failed : " + e.getMessage());
        }
        st.start();
        try {
            st.join();
        } catch (InterruptedException e) {
        }
        tg.destroy();
    }

    /**
     * @tests java.lang.Thread#countStackFrames()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "if this thread is not suspended, countStackFrames() method " +
            "should throw IllegalThreadStateException.",
      targets = {
        @TestTarget(
          methodName = "countStackFrames",
          methodArgs = {}
        )
    })
    @SuppressWarnings("deprecation")
    public void test_countStackFrames() {
        /*
         * Thread.countStackFrames() is unpredictable, so we just test that it
         * doesn't throw an exception.
         */
        try {
            Thread.currentThread().countStackFrames();
        } catch (Throwable t) {
            fail("unexpected throwable: " + t.toString());
        }
    }

    /**
     * @tests java.lang.Thread#currentThread()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "currentThread",
          methodArgs = {}
        )
    })
    public void test_currentThread() {
        assertNotNull(Thread.currentThread());
    }

    /**
     * @tests java.lang.Thread#destroy()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "NoSuchMethodError should be thrown. Need to add verification.",
      targets = {
        @TestTarget(
          methodName = "destroy",
          methodArgs = {}
        )
    })
    @SuppressWarnings("deprecation")
    public void test_destroy() {
        try {
            new Thread().destroy();
            // FIXME uncomment when IBM VME is updated
            //fail("NoSuchMethodError was not thrown");
        } catch (NoSuchMethodError e) {
        }
    }

    /**
     * @tests java.lang.Thread#enumerate(java.lang.Thread[])
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "enumerate",
          methodArgs = {java.lang.Thread[].class}
        )
    })
    public void _test_enumerate$Ljava_lang_Thread() {
        // Test for method int java.lang.Thread.enumerate(java.lang.Thread [])
        // The test has been updated according to HARMONY-1974 JIRA issue.

        class MyThread extends Thread {
            MyThread(ThreadGroup tg, String name) {
                super(tg, name);
            }

            boolean failed = false;
            String failMessage = null;

            public void run() {
                SimpleThread st1 = null;
                SimpleThread st2 = null;
                ThreadGroup mytg = null;
                Thread firstOne = null;
                Thread secondOne = null;
                try {
                    int arrayLength = 10;
                    Thread[] tarray = new Thread[arrayLength];
                    st1 = new SimpleThread(-1);
                    st2 = new SimpleThread(-1);
                    mytg = new ThreadGroup("jp");
                    firstOne = new Thread(mytg, st1, "firstOne2");
                    secondOne = new Thread(mytg, st2, "secondOne1");
                    int count = Thread.enumerate(tarray);
                    assertEquals("Incorrect value returned1",
                            1, count);
                    synchronized (st1) {
                        firstOne.start();
                        try {
                            st1.wait();
                        } catch (InterruptedException e) {
                        }
                    }
                    count = Thread.enumerate(tarray);
                    assertEquals("Incorrect value returned2",
                            2, count);
                    synchronized (st2) {
                        secondOne.start();
                        try {
                            st2.wait();
                        } catch (InterruptedException e) {
                        }
                    }
                    count = Thread.enumerate(tarray);
                    assertEquals("Incorrect value returned3",
                            3, count);
                } catch (junit.framework.AssertionFailedError e) {
                    failed = true;
                    failMessage = e.getMessage();
                } finally {
                    synchronized (st1) {
                        firstOne.interrupt();
                    }
                    synchronized (st2) {
                        secondOne.interrupt();
                    }
                    try {
                        firstOne.join();
                        secondOne.join();
                    } catch (InterruptedException e) {
                    }
                    mytg.destroy();
                }
            }
        };

        ThreadGroup tg = new ThreadGroup("tg");
        MyThread t = new MyThread(tg, "top");
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            fail("Unexpected interrupt");
        } finally {
            tg.destroy();
        }
        assertFalse(t.failMessage, t.failed);
    }

    /**
     * @tests java.lang.Thread#getContextClassLoader()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "getContextClassLoader",
          methodArgs = {}
        )
    })
    public void test_getContextClassLoader() {
        // Test for method java.lang.ClassLoader
        // java.lang.Thread.getContextClassLoader()
        Thread t = new Thread();
        assertTrue("Incorrect class loader returned",
                t.getContextClassLoader() == Thread.currentThread()
                        .getContextClassLoader());
        t.start();

    }

    /**
     * @tests java.lang.Thread#getName()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "getName",
          methodArgs = {}
        )
    })
    public void test_getName() {
        // Test for method java.lang.String java.lang.Thread.getName()
        st = new Thread(new SimpleThread(1), "SimpleThread6");
        assertEquals("Returned incorrect thread name",
                "SimpleThread6", st.getName());
        st.start();
    }

    /**
     * @tests java.lang.Thread#getPriority()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "getPriority",
          methodArgs = {}
        )
    })
    public void test_getPriority() {
        // Test for method int java.lang.Thread.getPriority()
        st = new Thread(new SimpleThread(1));
        st.setPriority(Thread.MAX_PRIORITY);
        assertTrue("Returned incorrect thread priority",
                st.getPriority() == Thread.MAX_PRIORITY);
        st.start();
    }

    /**
     * @tests java.lang.Thread#getThreadGroup()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "getThreadGroup",
          methodArgs = {}
        )
    })
    public void test_getThreadGroup() {
        // Test for method java.lang.ThreadGroup
        // java.lang.Thread.getThreadGroup()
        ThreadGroup tg = new ThreadGroup("Test Group4");
        st = new Thread(tg, /* new SimpleThread(1), */ "SimpleThread8");
        assertTrue("Returned incorrect thread group", st.getThreadGroup() == tg);
        st.start();
        try {
            st.join();
        } catch (InterruptedException e) {
        }
        assertNull("group should be null", st.getThreadGroup());
        assertNotNull("toString() should not be null", st.toString());
        tg.destroy();

        final Object lock = new Object();
        Thread t = new Thread() {
            @Override
            public void run() {
                synchronized (lock) {
                    lock.notifyAll();
                }
            }
        };
        synchronized (lock) {
            t.start();
            try {
                lock.wait();
            } catch (InterruptedException e) {
            }
        }
        int running = 0;
        while (t.isAlive())
            running++;
        ThreadGroup group = t.getThreadGroup();
        assertNull("ThreadGroup is not null", group);
    }

    /**
     * @tests java.lang.Thread#interrupt()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "interrupt",
          methodArgs = {}
        )
    })
    public void test_interrupt() {
        // Test for method void java.lang.Thread.interrupt()
        final Object lock = new Object();
        class ChildThread1 extends Thread {
            Thread parent;

            boolean sync;

            @Override
            public void run() {
                if (sync) {
                    synchronized (lock) {
                        lock.notify();
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                        }
                    }
                }
                parent.interrupt();
            }

            public ChildThread1(Thread p, String name, boolean sync) {
                super(name);
                parent = p;
                this.sync = sync;
            }
        }
        boolean interrupted = false;
        try {
            ct = new ChildThread1(Thread.currentThread(), "Interrupt Test1",
                    false);
            synchronized (lock) {
                ct.start();
                lock.wait();
            }
        } catch (InterruptedException e) {
            interrupted = true;
        }
        assertTrue("Failed to Interrupt thread1", interrupted);

        interrupted = false;
        try {
            ct = new ChildThread1(Thread.currentThread(), "Interrupt Test2",
                    true);
            synchronized (lock) {
                ct.start();
                lock.wait();
                lock.notify();
            }
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            interrupted = true;
        }
        assertTrue("Failed to Interrupt thread2", interrupted);

    }

    /**
     * @tests java.lang.Thread#interrupted()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "interrupted",
          methodArgs = {}
        )
    })
    public void test_interrupted() {
        assertFalse("Interrupted returned true for non-interrupted thread", Thread
                .interrupted());
        Thread.currentThread().interrupt();
        assertTrue("Interrupted returned true for non-interrupted thread", Thread.interrupted());
        assertFalse("Failed to clear interrupted flag", Thread.interrupted());
    }

    /**
     * @tests java.lang.Thread#isAlive()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "Need to check after interrupt(), etc...",
      targets = {
        @TestTarget(
          methodName = "isAlive",
          methodArgs = {}
        )
    })
    public void test_isAlive() {
        // Test for method boolean java.lang.Thread.isAlive()
        SimpleThread simple;
        st = new Thread(simple = new SimpleThread(500));
        assertFalse("A thread that wasn't started is alive.", st.isAlive());
        synchronized (simple) {
            st.start();
            try {
                simple.wait();
            } catch (InterruptedException e) {
            }
        }
        assertTrue("Started thread returned false", st.isAlive());
        try {
            st.join();
        } catch (InterruptedException e) {
            fail("Thread did not die");
        }
        assertTrue("Stopped thread returned true", !st.isAlive());
    }

    /**
     * @tests java.lang.Thread#isDaemon()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "isDaemon",
          methodArgs = {}
        )
    })
    public void test_isDaemon() {
        // Test for method boolean java.lang.Thread.isDaemon()
        st = new Thread(new SimpleThread(1), "SimpleThread10");
        assertTrue("Non-Daemon thread returned true", !st.isDaemon());
        st.setDaemon(true);
        assertTrue("Daemon thread returned false", st.isDaemon());
        st.start();
    }

    /**
     * @tests java.lang.Thread#isInterrupted()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "isInterrupted",
          methodArgs = {}
        )
    })
    public void test_isInterrupted() {
        // Test for method boolean java.lang.Thread.isInterrupted()
        class SpinThread implements Runnable {
            public volatile boolean done = false;

            public void run() {
                while (!Thread.currentThread().isInterrupted())
                    ;
                while (!done)
                    ;
            }
        }

        SpinThread spin = new SpinThread();
        spinner = new Thread(spin);
        spinner.start();
        Thread.yield();
        try {
            assertTrue("Non-Interrupted thread returned true", !spinner
                    .isInterrupted());
            spinner.interrupt();
            assertTrue("Interrupted thread returned false", spinner
                    .isInterrupted());
            spin.done = true;
        } finally {
            spinner.interrupt();
            spin.done = true;
        }
    }

    /**
     * @tests java.lang.Thread#join()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "InterruptedException is not verified.",
      targets = {
        @TestTarget(
          methodName = "join",
          methodArgs = {}
        )
    })
    public void test_join() {
        // Test for method void java.lang.Thread.join()
        SimpleThread simple;
        try {
            st = new Thread(simple = new SimpleThread(100));
            // cause isAlive() to be compiled by the JIT, as it must be called
            // within 100ms below.
            assertTrue("Thread is alive", !st.isAlive());
            synchronized (simple) {
                st.start();
                simple.wait();
            }
            st.join();
        } catch (InterruptedException e) {
            fail("Join failed ");
        }
        assertTrue("Joined thread is still alive", !st.isAlive());
        boolean result = true;
        Thread th = new Thread("test");
        try {
            th.join();
        } catch (InterruptedException e) {
            result = false;
        }
        assertTrue("Hung joining a non-started thread", result);
        th.start();
    }

    /**
     * @tests java.lang.Thread#join(long)
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "InterruptedException is not verified.",
      targets = {
        @TestTarget(
          methodName = "join",
          methodArgs = {long.class}
        )
    })
    public void test_joinJ() {
        // Test for method void java.lang.Thread.join(long)
        SimpleThread simple;
        try {
            st = new Thread(simple = new SimpleThread(1000), "SimpleThread12");
            // cause isAlive() to be compiled by the JIT, as it must be called
            // within 100ms below.
            assertTrue("Thread is alive", !st.isAlive());
            synchronized (simple) {
                st.start();
                simple.wait();
            }
            st.join(10);
        } catch (InterruptedException e) {
            fail("Join failed ");
        }
        assertTrue("Join failed to timeout", st.isAlive());

        st.interrupt();
        try {
            st = new Thread(simple = new SimpleThread(100), "SimpleThread13");
            synchronized (simple) {
                st.start();
                simple.wait();
            }
            st.join(1000);
        } catch (InterruptedException e) {
            fail("Join failed : " + e.getMessage());
            return;
        }
        assertTrue("Joined thread is still alive", !st.isAlive());

        final Object lock = new Object();
        final Thread main = Thread.currentThread();
        Thread killer = new Thread(new Runnable() {
            public void run() {
                try {
                    synchronized (lock) {
                        lock.notify();
                    }
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    return;
                }
                main.interrupt();
            }
        });
        boolean result = true;
        Thread th = new Thread("test");
        try {
            synchronized (lock) {
                killer.start();
                lock.wait();
            }
            th.join(200);
        } catch (InterruptedException e) {
            result = false;
        }
        killer.interrupt();
        assertTrue("Hung joining a non-started thread", result);
        th.start();
    }

    /**
     * @tests java.lang.Thread#join(long, int)
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "InterruptedException is not verified.",
      targets = {
        @TestTarget(
          methodName = "join",
          methodArgs = {long.class, int.class}
        )
    })
    public void test_joinJI() {
        // Test for method void java.lang.Thread.join(long, int)
        SimpleThread simple;
        try {
            st = new Thread(simple = new SimpleThread(1000), "Squawk1");
            assertTrue("Thread is alive", !st.isAlive());
            synchronized (simple) {
                st.start();
                simple.wait();
            }

            long firstRead = System.currentTimeMillis();
            st.join(100, 999999);
            long secondRead = System.currentTimeMillis();
            assertTrue("Did not join by appropriate time: " + secondRead + "-"
                    + firstRead + "=" + (secondRead - firstRead), secondRead
                    - firstRead <= 300);
            assertTrue("Joined thread is not alive", st.isAlive());
            st.interrupt();
        } catch (Exception e) {
            fail("Exception during test : " + e.getMessage());
        }

        final Object lock = new Object();
        final Thread main = Thread.currentThread();
        Thread killer = new Thread(new Runnable() {
            public void run() {
                try {
                    synchronized (lock) {
                        lock.notify();
                    }
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    return;
                }
                main.interrupt();
            }
        });
        boolean result = true;
        Thread th = new Thread("test");
        try {
            synchronized (lock) {
                killer.start();
                lock.wait();
            }
            th.join(200, 20);
        } catch (InterruptedException e) {
            result = false;
        }
        killer.interrupt();
        assertTrue("Hung joining a non-started thread", result);
        th.start();
    }

    /**
     * @tests java.lang.Thread#resume()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "resume",
          methodArgs = {}
        )
    })
    @SuppressWarnings("deprecation")
    public void _test_resume() {
        // Test for method void java.lang.Thread.resume()
        int orgval;
        ResSupThread t;
        try {
            t = new ResSupThread(Thread.currentThread());
            synchronized (t) {
                ct = new Thread(t, "Interrupt Test2");
                ct.start();
                t.wait();
            }
            ct.suspend();
            // Wait to be sure the suspend has occurred
            Thread.sleep(500);
            orgval = t.getCheckVal();
            // Wait to be sure the thread is suspended
            Thread.sleep(500);
            assertTrue("Failed to suspend thread", orgval == t.getCheckVal());
            ct.resume();
            // Wait to be sure the resume has occurred.
            Thread.sleep(500);
            assertTrue("Failed to resume thread", orgval != t.getCheckVal());
            ct.interrupt();
        } catch (InterruptedException e) {
            fail("Unexpected interrupt occurred : " + e.getMessage());
        }
    }

    /**
     * @tests java.lang.Thread#run()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "run",
          methodArgs = {}
        )
    })
    public void test_run() {
        // Test for method void java.lang.Thread.run()
        class RunThread implements Runnable {
            boolean didThreadRun = false;

            public void run() {
                didThreadRun = true;
            }
        }
        RunThread rt = new RunThread();
        Thread t = new Thread(rt);
        try {
            t.start();
            int count = 0;
            while (!rt.didThreadRun && count < 20) {
                Thread.sleep(100);
                count++;
            }
            assertTrue("Thread did not run", rt.didThreadRun);
            t.join();
        } catch (InterruptedException e) {
            assertTrue("Joined thread was interrupted", true);
        }
        assertTrue("Joined thread is still alive", !t.isAlive());
    }

    /**
     * @tests java.lang.Thread#setDaemon(boolean)
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "Exceptions are not verified.",
      targets = {
        @TestTarget(
          methodName = "setDaemon",
          methodArgs = {boolean.class}
        )
    })
    public void test_setDaemonZ() {
        // Test for method void java.lang.Thread.setDaemon(boolean)
        st = new Thread(new SimpleThread(1), "SimpleThread14");
        st.setDaemon(true);
        assertTrue("Failed to set thread as daemon thread", st.isDaemon());
        st.start();

        // BEGIN android-added
        st = new Thread(new SimpleThread(5));
        st.start();
        try {
            st.setDaemon(false);
            fail("setDaemon() must throw exception for started thread");
        } catch (IllegalThreadStateException ex) {
            // We expect this one.
        }
        // END android-added
    }

    /**
     * @tests java.lang.Thread#setName(java.lang.String)
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "setName",
          methodArgs = {java.lang.String.class}
        )
    })
    public void test_setNameLjava_lang_String() {
        // Test for method void java.lang.Thread.setName(java.lang.String)
        st = new Thread(new SimpleThread(1), "SimpleThread15");
        st.setName("Bogus Name");
        assertEquals("Failed to set thread name",
                "Bogus Name", st.getName());
        try {
            st.setName(null);
            fail("Null should not be accepted as a valid name");
        } catch (NullPointerException e) {
            // success
            assertTrue("Null should not be accepted as a valid name", true);
        }
        st.start();
    }

    /**
     * @tests java.lang.Thread#setPriority(int)
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "Exceptions are not verified.",
      targets = {
        @TestTarget(
          methodName = "setPriority",
          methodArgs = {int.class}
        )
    })
    public void test_setPriorityI() {
        // Test for method void java.lang.Thread.setPriority(int)
        st = new Thread(new SimpleThread(1));
        st.setPriority(Thread.MAX_PRIORITY);
        assertTrue("Failed to set priority",
                st.getPriority() == Thread.MAX_PRIORITY);
        st.start();
    }

    /**
     * @tests java.lang.Thread#sleep(long)
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "InterruptedException is not verified. Test needs enhancing.",
      targets = {
        @TestTarget(
          methodName = "sleep",
          methodArgs = {long.class}
        )
    })
    public void test_sleepJ() {
        // Test for method void java.lang.Thread.sleep(long)

        // TODO : Test needs enhancing.
        long stime = 0, ftime = 0;
        try {
            stime = System.currentTimeMillis();
            Thread.sleep(1000);
            ftime = System.currentTimeMillis();
        } catch (InterruptedException e) {
            fail("Unexpected interrupt received");
        }
        assertTrue("Failed to sleep long enough", (ftime - stime) >= 800);
    }

    /**
     * @tests java.lang.Thread#sleep(long, int)
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "Exceptions are not verified. Test needs revisiting.",
      targets = {
        @TestTarget(
          methodName = "sleep",
          methodArgs = {long.class, int.class}
        )
    })
    public void test_sleepJI() {
        // Test for method void java.lang.Thread.sleep(long, int)

        // TODO : Test needs revisiting.
        long stime = 0, ftime = 0;
        try {
            stime = System.currentTimeMillis();
            Thread.sleep(1000, 999999);
            ftime = System.currentTimeMillis();
        } catch (InterruptedException e) {
            fail("Unexpected interrupt received");
        }
        long result = ftime - stime;
        assertTrue("Failed to sleep long enough: " + result, result >= 900
                && result <= 1100);
    }

    /**
     * @tests java.lang.Thread#start()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "IllegalThreadStateException is not verified. " +
            "Test needs revisiting.",
      targets = {
        @TestTarget(
          methodName = "start",
          methodArgs = {}
        )
    })
    public void test_start() {
        // Test for method void java.lang.Thread.start()
        try {
            ResSupThread t = new ResSupThread(Thread.currentThread());
            synchronized (t) {
                ct = new Thread(t, "Interrupt Test4");
                ct.start();
                t.wait();
            }
            assertTrue("Thread is not running1", ct.isAlive());
            // Let the child thread get going.
            int orgval = t.getCheckVal();
            Thread.sleep(150);
            assertTrue("Thread is not running2", orgval != t.getCheckVal());
            ct.interrupt();
        } catch (InterruptedException e) {
            fail("Unexpected interrupt occurred");
        }
    }

    /**
     * @tests java.lang.Thread#stop()
     */
    @TestInfo(
      level = TestLevel.PARTIAL_OK,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "stop",
          methodArgs = {}
        )
    })
    @SuppressWarnings("deprecation")
    public void _test_stop() {
        // Test for method void java.lang.Thread.stop()
        try {
            Runnable r = new ResSupThread(null);
            synchronized (r) {
                st = new Thread(r, "Interupt Test5");
                st.start();
                r.wait();
            }

        } catch (InterruptedException e) {
            fail("Unexpected interrupt received");
        }
        st.stop();

        try {
            st.join(10000);
        } catch (InterruptedException e1) {
            st.interrupt();
            fail("Failed to stopThread before 10000 timeout");
        }
        assertTrue("Failed to stopThread", !st.isAlive());
    }

    /**
     * @tests java.lang.Thread#stop()
     */
    @TestInfo(
      level = TestLevel.PARTIAL_OK,
      purpose = "Verifies security.",
      targets = {
        @TestTarget(
          methodName = "stop",
          methodArgs = {}
        )
    })
    @SuppressWarnings("deprecation")
    public void test_stop_subtest0() {
        Thread t = new Thread("t");
        class MySecurityManager extends SecurityManager {
            public boolean intest = false;

            @Override
            public void checkAccess(Thread t) {
// TODO(Fixed) The JDK expects exactly this security check. Test must be wrong.
//                if (intest) {
//                    fail("checkAccess called");
//                }
            }
            @Override
            public void checkPermission(Permission permission) {
                if (permission.getName().equals("setSecurityManager")) {
                    return;
                }
                super.checkPermission(permission);
            }
        }
        MySecurityManager sm = new MySecurityManager();
        System.setSecurityManager(sm);
        try {
            sm.intest = true;
            try {
                t.stop();
                // Ignore any SecurityExceptions, may not have stopThread
                // permission
            } catch (SecurityException e) {
            }
            sm.intest = false;
            t.start();
            try {
                t.join(2000);
            } catch (InterruptedException e) {
            }
            sm.intest = true;
            try {
                t.stop();
                // Ignore any SecurityExceptions, may not have stopThread
                // permission
            } catch (SecurityException e) {
            }
            sm.intest = false;
        } finally {
            System.setSecurityManager(null);
        }
    }

    /**
     * @tests java.lang.Thread#stop(java.lang.Throwable)
     */
    @TestInfo(
      level = TestLevel.PARTIAL_OK,
      purpose = "Verifies security.",
      targets = {
        @TestTarget(
          methodName = "stop",
          methodArgs = {java.lang.Throwable.class}
        )
    })
    @SuppressWarnings("deprecation")
    public void test_stopLjava_lang_Throwable_subtest0() {
        Thread t = new Thread("t");
        class MySecurityManager extends SecurityManager {
            public boolean intest = false;

            public boolean checkAccess = false;

            @Override
            public void checkAccess(Thread t) {
                if (intest) {
                    checkAccess = true;
                }
            }
            @Override
            public void checkPermission(Permission permission) {
                if (permission.getName().equals("setSecurityManager")) {
                    return;
                }
                super.checkPermission(permission);
            }
        }
        MySecurityManager sm = new MySecurityManager();
        System.setSecurityManager(sm);
        try {
            sm.intest = true;
            try {
                t.stop(new ThreadDeath());
                // Ignore any SecurityExceptions, may not have stopThread
                // permission
            } catch (SecurityException e) {
            }
            sm.intest = false;
            assertTrue("no checkAccess 1", sm.checkAccess);
            t.start();
            try {
                t.join(2000);
            } catch (InterruptedException e) {
            }
            sm.intest = true;
            sm.checkAccess = false;
            try {
                t.stop(new ThreadDeath());
                // Ignore any SecurityExceptions, may not have stopThread
                // permission
            } catch (SecurityException e) {
            }
            assertTrue("no checkAccess 2", sm.checkAccess);
            sm.intest = false;
        } finally {
            System.setSecurityManager(null);
        }
    }

    /**
     * @tests java.lang.Thread#stop(java.lang.Throwable)
     */
    @TestInfo(
      level = TestLevel.PARTIAL_OK,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "stop",
          methodArgs = {java.lang.Throwable.class}
        )
    })
    @SuppressWarnings("deprecation")
    public void _test_stopLjava_lang_Throwable() {
        // Test for method void java.lang.Thread.stop(java.lang.Throwable)
        ResSupThread t = new ResSupThread(Thread.currentThread());
        synchronized (t) {
            st = new Thread(t, "StopThread");
            st.setPriority(Thread.MAX_PRIORITY);
            st.start();
            try {
                t.wait();
            } catch (InterruptedException e) {
            }
        }
        try {
            st.stop(new BogusException("Bogus"));
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            assertTrue("Stopped child with exception not alive", st.isAlive());
            st.interrupt();
            return;
        }
        st.interrupt();
        fail("Stopped child did not throw exception");
    }

    /**
     * @tests java.lang.Thread#suspend()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "suspend",
          methodArgs = {}
        )
    })
    @SuppressWarnings("deprecation")
    public void _test_suspend() {
        // Test for method void java.lang.Thread.suspend()
        int orgval;
        ResSupThread t = new ResSupThread(Thread.currentThread());
        try {
            synchronized (t) {
                ct = new Thread(t, "Interupt Test6");
                ct.start();
                t.wait();
            }
            ct.suspend();
            // Wait to be sure the suspend has occurred
            Thread.sleep(500);
            orgval = t.getCheckVal();
            // Wait to be sure the thread is suspended
            Thread.sleep(500);
            assertTrue("Failed to suspend thread", orgval == t.getCheckVal());
            ct.resume();
            // Wait to be sure the resume has occurred.
            Thread.sleep(500);
            assertTrue("Failed to resume thread", orgval != t.getCheckVal());
            ct.interrupt();
        } catch (InterruptedException e) {
            fail("Unexpected interrupt occurred");
        }

        final Object notify = new Object();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                synchronized (notify) {
                    notify.notify();
                }
                Thread.currentThread().suspend();
            }
        });
        try {
            synchronized (notify) {
                t1.start();
                notify.wait();
            }
            // wait for Thread to suspend
            Thread.sleep(500);
            assertTrue("Thread should be alive", t1.isAlive());
            t1.resume();
            t1.join();
        } catch (InterruptedException e) {
        }
    }

    /**
     * @tests java.lang.Thread#toString()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "toString",
          methodArgs = {}
        )
    })
    public void test_toString() {
        // Test for method java.lang.String java.lang.Thread.toString()
        ThreadGroup tg = new ThreadGroup("Test Group5");
        st = new Thread(tg, new SimpleThread(1), "SimpleThread17");
        final String stString = st.toString();
        final String expected = "Thread[SimpleThread17,5,Test Group5]";
        assertTrue("Returned incorrect string: " + stString + "\t(expecting :"
                + expected + ")", stString.equals(expected));
        st.start();
        try {
            st.join();
        } catch (InterruptedException e) {
        }
        tg.destroy();
    }

    /**
     * @tests java.lang.Thread#getAllStackTraces()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "getAllStackTraces",
          methodArgs = {}
        )
    })
    public void test_getAllStackTraces() {
        Map<Thread, StackTraceElement[]> stMap = Thread.getAllStackTraces();
        assertNotNull(stMap);
        //TODO add security-based tests
    }

    /**
     * @tests java.lang.Thread#getDefaultUncaughtExceptionHandler
     * @tests java.lang.Thread#setDefaultUncaughtExceptionHandler
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "setUncaughtExceptionHandler",
          methodArgs = {java.lang.Thread.UncaughtExceptionHandler.class}
        ),
        @TestTarget(
          methodName = "getDefaultUncaughtExceptionHandler",
          methodArgs = {}
        )
    })
    public void test_get_setDefaultUncaughtExceptionHandler() {
        class Handler implements UncaughtExceptionHandler {
            public void uncaughtException(Thread thread, Throwable ex) {
            }
        }

        final Handler handler = new Handler();
        Thread.setDefaultUncaughtExceptionHandler(handler);
        assertSame(handler, Thread.getDefaultUncaughtExceptionHandler());

        Thread.setDefaultUncaughtExceptionHandler(null);
        assertNull(Thread.getDefaultUncaughtExceptionHandler());
        //TODO add security-based tests
    }

    /**
     * @tests java.lang.Thread#getStackTrace()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "getStackTrace",
          methodArgs = {}
        )
    })
    public void test_getStackTrace() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();

        assertNotNull(stackTrace);

        stack_trace_loop: {
            for (int i = 0; i < stackTrace.length; i++) {
                StackTraceElement e = stackTrace[i];
                if (getClass().getName().equals(e.getClassName())) {
                    if ("test_getStackTrace".equals(e.getMethodName())) {
                        break stack_trace_loop;
                    }
                }
            }
            fail("class and method not found in stack trace");
        }

        //TODO add security-based tests
    }

    /**
     * @tests java.lang.Thread#getState()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "add additional state tests.",
      targets = {
        @TestTarget(
          methodName = "getState",
          methodArgs = {}
        )
    })
    public void test_getState() {
        Thread.State state = Thread.currentThread().getState();
        assertNotNull(state);
        assertEquals(Thread.State.RUNNABLE, state);
        //TODO add additional state tests
    }

    /**
     * @tests java.lang.Thread#getUncaughtExceptionHandler
     * @tests java.lang.Thread#setUncaughtExceptionHandler
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "SecurityException is not verified.",
      targets = {
        @TestTarget(
          methodName = "getDefaultUncaughtExceptionHandler",
          methodArgs = {}
        ),
        @TestTarget(
          methodName = "setDefaultUncaughtExceptionHandler",
          methodArgs = {java.lang.Thread.UncaughtExceptionHandler.class}
        )
    })
    public void test_get_setUncaughtExceptionHandler() {
        class Handler implements UncaughtExceptionHandler {
            public void uncaughtException(Thread thread, Throwable ex) {
            }
        }

        final Handler handler = new Handler();
        Thread.currentThread().setUncaughtExceptionHandler(handler);
        assertSame(handler, Thread.currentThread().getUncaughtExceptionHandler());

        Thread.currentThread().setUncaughtExceptionHandler(null);

        //TODO add security-based tests
    }

    /**
     * @tests java.lang.Thread#getId()
     */
    @TestInfo(
      level = TestLevel.COMPLETE,
      purpose = "",
      targets = {
        @TestTarget(
          methodName = "getId",
          methodArgs = {}
        )
    })
    public void test_getId() {
        assertTrue("current thread's ID is not positive", Thread.currentThread().getId() > 0);

        //check all the current threads for positive IDs
        Map<Thread, StackTraceElement[]> stMap = Thread.getAllStackTraces();
        for (Thread thread : stMap.keySet()) {
            assertTrue("thread's ID is not positive: " + thread.getName(), thread.getId() > 0);
        }
    }

    /**
     * @tests java.lang.Thread#holdLock()
     */
    @TestInfo(
      level = TestLevel.PARTIAL,
      purpose = "NullPointerException is not verified.",
      targets = {
        @TestTarget(
          methodName = "holdsLock",
          methodArgs = {java.lang.Object.class}
        )
    })
    public void test_holdsLock() {
        MonitoredClass monitor = new MonitoredClass();

        monitor.enterLocked();
        monitor.enterNonLocked();
    }

    @Override
    protected void tearDown() {
        try {
            if (st != null)
                st.interrupt();
        } catch (Exception e) {
        }
        try {
            if (spinner != null)
                spinner.interrupt();
        } catch (Exception e) {
        }
        try {
            if (ct != null)
                ct.interrupt();
        } catch (Exception e) {
        }

        try {
            spinner = null;
            st = null;
            ct = null;
            System.runFinalization();
        } catch (Exception e) {
        }
    }
}