undefect. CWE-407 — 63 sites patched across 27 ecosystems
Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com Patches, unit tests, benchmarks, whitepaper, and outreach briefs. Public domain — no copyright claimed. Use freely.
This commit is contained in:
commit
0a580b313d
70422 changed files with 17213626 additions and 0 deletions
822
test/jdk/java/lang/ThreadGroup/BasicTests.java
Normal file
822
test/jdk/java/lang/ThreadGroup/BasicTests.java
Normal file
|
|
@ -0,0 +1,822 @@
|
|||
/*
|
||||
* Copyright (c) 2020, 2023, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @test
|
||||
* @summary Unit tests for java.lang.ThreadGroup
|
||||
* @run junit BasicTests
|
||||
*/
|
||||
|
||||
import java.lang.ref.WeakReference;
|
||||
import java.util.Arrays;
|
||||
import java.util.Objects;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.locks.LockSupport;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class BasicTests {
|
||||
|
||||
@Test
|
||||
void testGetName1() {
|
||||
ThreadGroup group = new ThreadGroup(null);
|
||||
assertTrue(group.getName() == null);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetName2() {
|
||||
ThreadGroup group = new ThreadGroup("fred");
|
||||
assertEquals("fred", group.getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetParent() {
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
ThreadGroup group3 = new ThreadGroup(group2, "group3");
|
||||
|
||||
assertTrue(group1.getParent() == Thread.currentThread().getThreadGroup());
|
||||
assertTrue(group2.getParent() == group1);
|
||||
assertTrue(group3.getParent() == group2);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testParentOf() {
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
ThreadGroup group3 = new ThreadGroup(group2, "group3");
|
||||
|
||||
assertFalse(group1.parentOf(null));
|
||||
assertTrue(group1.parentOf(group1));
|
||||
assertTrue(group1.parentOf(group2));
|
||||
assertTrue(group1.parentOf(group3));
|
||||
|
||||
assertFalse(group2.parentOf(null));
|
||||
assertFalse(group2.parentOf(group1));
|
||||
assertTrue(group2.parentOf(group2));
|
||||
assertTrue(group2.parentOf(group3));
|
||||
|
||||
assertFalse(group3.parentOf(null));
|
||||
assertFalse(group3.parentOf(group1));
|
||||
assertFalse(group3.parentOf(group2));
|
||||
assertTrue(group3.parentOf(group3));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testActiveCount1() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
assertTrue(group.activeCount() == 0);
|
||||
TestThread thread = TestThread.start(group, "foo");
|
||||
try {
|
||||
assertTrue(group.activeCount() == 1);
|
||||
} finally {
|
||||
thread.terminate();
|
||||
}
|
||||
assertTrue(group.activeCount() == 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testActiveCount2() {
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
assertTrue(group1.activeCount() == 0);
|
||||
assertTrue(group2.activeCount() == 0);
|
||||
TestThread thread1 = TestThread.start(group1, "foo");
|
||||
try {
|
||||
assertTrue(group1.activeCount() == 1);
|
||||
assertTrue(group2.activeCount() == 0);
|
||||
TestThread thread2 = TestThread.start(group2, "bar");
|
||||
try {
|
||||
assertTrue(group1.activeCount() == 2);
|
||||
assertTrue(group2.activeCount() == 1);
|
||||
} finally {
|
||||
thread2.terminate();
|
||||
}
|
||||
assertTrue(group1.activeCount() == 1);
|
||||
assertTrue(group2.activeCount() == 0);
|
||||
} finally {
|
||||
thread1.terminate();
|
||||
}
|
||||
assertTrue(group1.activeCount() == 0);
|
||||
assertTrue(group2.activeCount() == 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void enumerateThreads1() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
Thread[] threads = new Thread[100];
|
||||
assertTrue(group.enumerate(threads) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group.enumerate(threads, true) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group.enumerate(threads, false) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
TestThread thread = TestThread.start(group, "foo");
|
||||
try {
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group.enumerate(threads) == 1);
|
||||
assertTrue(threads[0] == thread);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group.enumerate(threads, true) == 1);
|
||||
assertTrue(threads[0] == thread);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group.enumerate(threads, false) == 1);
|
||||
assertTrue(threads[0] == thread);
|
||||
assertTrue(threads[1] == null);
|
||||
} finally {
|
||||
thread.terminate();
|
||||
}
|
||||
assertTrue(group.activeCount() == 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void enumerateThreads2() {
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
|
||||
Thread[] threads = new Thread[100];
|
||||
assertTrue(group1.enumerate(threads) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group1.enumerate(threads, true) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group1.enumerate(threads, false) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group2.enumerate(threads) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group2.enumerate(threads, true) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group2.enumerate(threads, false) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
|
||||
TestThread thread1 = TestThread.start(group1, "foo");
|
||||
try {
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads) == 1);
|
||||
assertTrue(threads[0] == thread1);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads, true) == 1);
|
||||
assertTrue(threads[0] == thread1);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads, false) == 1);
|
||||
assertTrue(threads[0] == thread1);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group2.enumerate(threads, true) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group2.enumerate(threads, false) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
|
||||
TestThread thread2 = TestThread.start(group2, "bar");
|
||||
try {
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads) == 2);
|
||||
assertEquals(Set.of(thread1, thread2), toSet(threads, 2));
|
||||
assertTrue(threads[2] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads, true) == 2);
|
||||
assertEquals(Set.of(thread1, thread2), toSet(threads, 2));
|
||||
assertTrue(threads[2] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads, false) == 1);
|
||||
assertTrue(threads[0] == thread1);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads) == 1);
|
||||
assertTrue(threads[0] == thread2);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads, true) == 1);
|
||||
assertTrue(threads[0] == thread2);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads, false) == 1);
|
||||
assertTrue(threads[0] == thread2);
|
||||
assertTrue(threads[1] == null);
|
||||
} finally {
|
||||
thread2.terminate();
|
||||
}
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads) == 1);
|
||||
assertTrue(threads[0] == thread1);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads, true) == 1);
|
||||
assertTrue(threads[0] == thread1);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads, false) == 1);
|
||||
assertTrue(threads[0] == thread1);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group2.enumerate(threads, true) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group2.enumerate(threads, false) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
} finally {
|
||||
thread1.terminate();
|
||||
}
|
||||
assertTrue(group1.activeCount() == 0);
|
||||
assertTrue(group2.activeCount() == 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void enumerateThreads3() {
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
ThreadGroup group3 = new ThreadGroup(group2, "group3");
|
||||
|
||||
Thread[] threads = new Thread[100];
|
||||
assertTrue(group1.enumerate(threads) == 0);
|
||||
assertTrue(group1.enumerate(threads, true) == 0);
|
||||
assertTrue(group1.enumerate(threads, false) == 0);
|
||||
assertTrue(group2.enumerate(threads) == 0);
|
||||
assertTrue(group2.enumerate(threads, true) == 0);
|
||||
assertTrue(group2.enumerate(threads, false) == 0);
|
||||
assertTrue(group3.enumerate(threads) == 0);
|
||||
assertTrue(group3.enumerate(threads, true) == 0);
|
||||
assertTrue(group3.enumerate(threads, false) == 0);
|
||||
|
||||
TestThread thread2 = TestThread.start(group2, "foo");
|
||||
try {
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads) == 1);
|
||||
assertTrue(group1.enumerate(threads, true) == 1);
|
||||
assertTrue(group1.enumerate(threads, false) == 0);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads) == 1);
|
||||
assertTrue(threads[0] == thread2);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads, true) == 1);
|
||||
assertTrue(threads[0] == thread2);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads, false) == 1);
|
||||
assertTrue(threads[0] == thread2);
|
||||
|
||||
assertTrue(group3.enumerate(threads) == 0);
|
||||
assertTrue(group3.enumerate(threads, true) == 0);
|
||||
assertTrue(group3.enumerate(threads, false) == 0);
|
||||
|
||||
TestThread thread3 = TestThread.start(group3, "bar");
|
||||
try {
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads) == 2);
|
||||
assertEquals(Set.of(thread2, thread3), toSet(threads, 2));
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads, true) == 2);
|
||||
assertEquals(Set.of(thread2, thread3), toSet(threads, 2));
|
||||
assertTrue(group1.enumerate(threads, false) == 0);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads) == 2);
|
||||
assertEquals(Set.of(thread2, thread3), toSet(threads, 2));
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads, true) == 2);
|
||||
assertEquals(Set.of(thread2, thread3), toSet(threads, 2));
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads, false) == 1);
|
||||
assertTrue(threads[0] == thread2);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group3.enumerate(threads) == 1);
|
||||
assertTrue(threads[0] == thread3);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group3.enumerate(threads, true) == 1);
|
||||
assertTrue(threads[0] == thread3);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group3.enumerate(threads, false) == 1);
|
||||
assertTrue(threads[0] == thread3);
|
||||
} finally {
|
||||
thread3.terminate();
|
||||
}
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads) == 1);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads, true) == 1);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group1.enumerate(threads, false) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads) == 1);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads, true) == 1);
|
||||
assertTrue(threads[0] == thread2);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group2.enumerate(threads, false) == 1);
|
||||
assertTrue(threads[0] == thread2);
|
||||
assertTrue(threads[1] == null);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group3.enumerate(threads) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group3.enumerate(threads, true) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
assertTrue(group3.enumerate(threads, false) == 0);
|
||||
assertTrue(threads[0] == null);
|
||||
|
||||
} finally {
|
||||
thread2.terminate();
|
||||
}
|
||||
|
||||
assertTrue(group1.enumerate(threads) == 0);
|
||||
assertTrue(group1.enumerate(threads, true) == 0);
|
||||
assertTrue(group1.enumerate(threads, false) == 0);
|
||||
assertTrue(group2.enumerate(threads) == 0);
|
||||
assertTrue(group2.enumerate(threads, true) == 0);
|
||||
assertTrue(group2.enumerate(threads, false) == 0);
|
||||
assertTrue(group3.enumerate(threads) == 0);
|
||||
assertTrue(group3.enumerate(threads, true) == 0);
|
||||
assertTrue(group3.enumerate(threads, false) == 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test enumerate(Thread[]) with an array of insufficient size
|
||||
*/
|
||||
@Test
|
||||
void enumerateThreads4() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
|
||||
// array too small
|
||||
Thread[] threads = new Thread[1];
|
||||
|
||||
TestThread thread1 = TestThread.start(group, "thread1");
|
||||
TestThread thread2 = TestThread.start(group, "thread2");
|
||||
try {
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group.enumerate(threads) == 1);
|
||||
assertTrue(threads[0] == thread1 || threads[1] == thread2);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group.enumerate(threads, true) == 1);
|
||||
assertTrue(threads[0] == thread1 || threads[1] == thread2);
|
||||
|
||||
Arrays.setAll(threads, i -> null);
|
||||
assertTrue(group.enumerate(threads, false) == 1);
|
||||
assertTrue(threads[0] == thread1 || threads[1] == thread2);
|
||||
} finally {
|
||||
thread1.terminate();
|
||||
thread2.terminate();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void testActiveGroupCount() throws Exception {
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
assertTrue(group1.activeGroupCount() == 0);
|
||||
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
assertTrue(group1.activeGroupCount() == 1);
|
||||
assertTrue(group2.activeGroupCount() == 0);
|
||||
|
||||
ThreadGroup group3 = new ThreadGroup(group2, "group3");
|
||||
assertTrue(group1.activeGroupCount() == 2);
|
||||
assertTrue(group2.activeGroupCount() == 1);
|
||||
assertTrue(group3.activeGroupCount() == 0);
|
||||
|
||||
// unreference group3 and wait for it to be GC'ed
|
||||
var ref = new WeakReference<>(group3);
|
||||
group3 = null;
|
||||
System.gc();
|
||||
while (ref.get() != null) {
|
||||
Thread.sleep(50);
|
||||
}
|
||||
|
||||
assertTrue(group1.activeGroupCount() == 1);
|
||||
assertTrue(group2.activeGroupCount() == 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testEnumerateGroups1() throws Exception {
|
||||
ThreadGroup[] groups = new ThreadGroup[100];
|
||||
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
|
||||
assertTrue(group1.enumerate(groups) == 0);
|
||||
assertTrue(groups[0] == null);
|
||||
assertTrue(group1.enumerate(groups, true) == 0);
|
||||
assertTrue(groups[0] == null);
|
||||
assertTrue(group1.enumerate(groups, false) == 0);
|
||||
assertTrue(groups[0] == null);
|
||||
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group1.enumerate(groups) == 1);
|
||||
assertTrue(groups[0] == group2);
|
||||
assertTrue(groups[1] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group1.enumerate(groups, true) == 1);
|
||||
assertTrue(groups[0] == group2);
|
||||
assertTrue(groups[1] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group1.enumerate(groups, false) == 1);
|
||||
assertTrue(groups[0] == group2);
|
||||
assertTrue(groups[1] == null);
|
||||
|
||||
ThreadGroup group3 = new ThreadGroup(group2, "group3");
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group1.enumerate(groups) == 2);
|
||||
assertEquals(Set.of(group2, group3), toSet(groups, 2));
|
||||
assertTrue(groups[2] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group1.enumerate(groups, true) == 2);
|
||||
assertEquals(Set.of(group2, group3), toSet(groups, 2));
|
||||
assertTrue(groups[2] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group1.enumerate(groups, false) == 1);
|
||||
assertTrue(groups[0] == group2);
|
||||
assertTrue(groups[1] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group2.enumerate(groups) == 1);
|
||||
assertTrue(groups[0] == group3);
|
||||
assertTrue(groups[1] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group2.enumerate(groups, true) == 1);
|
||||
assertTrue(groups[0] == group3);
|
||||
assertTrue(groups[1] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group2.enumerate(groups, false) == 1);
|
||||
assertTrue(groups[0] == group3);
|
||||
assertTrue(groups[1] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group3.enumerate(groups) == 0);
|
||||
assertTrue(groups[0] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group3.enumerate(groups, true) == 0);
|
||||
assertTrue(groups[0] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group3.enumerate(groups, false) == 0);
|
||||
assertTrue(groups[0] == null);
|
||||
|
||||
// unreference group3 and wait for it to be GC'ed
|
||||
var ref = new WeakReference<>(group3);
|
||||
Arrays.setAll(groups, i -> null);
|
||||
group3 = null;
|
||||
System.gc();
|
||||
while (ref.get() != null) {
|
||||
Thread.sleep(50);
|
||||
}
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group1.enumerate(groups) == 1);
|
||||
assertTrue(groups[0] == group2);
|
||||
assertTrue(groups[1] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group1.enumerate(groups, true) == 1);
|
||||
assertTrue(groups[0] == group2);
|
||||
assertTrue(groups[1] == null);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group1.enumerate(groups, false) == 1);
|
||||
assertTrue(groups[0] == group2);
|
||||
assertTrue(groups[1] == null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test enumerate(ThreadGroup[]) with an array of insufficient size
|
||||
*/
|
||||
@Test
|
||||
void testEnumerateGroups2() throws Exception {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
ThreadGroup child1 = new ThreadGroup(group, "child1");
|
||||
ThreadGroup child2 = new ThreadGroup(group,"child2");
|
||||
|
||||
// array too small
|
||||
ThreadGroup[] groups = new ThreadGroup[1];
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group.enumerate(groups) == 1);
|
||||
assertTrue(groups[0] == child1 || groups[1] == child2);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group.enumerate(groups, true) == 1);
|
||||
assertTrue(groups[0] == child1 || groups[1] == child2);
|
||||
|
||||
Arrays.setAll(groups, i -> null);
|
||||
assertTrue(group.enumerate(groups, false) == 1);
|
||||
assertTrue(groups[0] == child1 || groups[1] == child2);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testMaxPriority1() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
final int maxPriority = group.getMaxPriority();
|
||||
assertTrue(maxPriority == Thread.currentThread().getThreadGroup().getMaxPriority());
|
||||
|
||||
group.setMaxPriority(Thread.MIN_PRIORITY-1);
|
||||
assertTrue(group.getMaxPriority() == maxPriority);
|
||||
|
||||
group.setMaxPriority(Thread.MAX_PRIORITY+1);
|
||||
assertTrue(group.getMaxPriority() == maxPriority);
|
||||
|
||||
group.setMaxPriority(maxPriority+1);
|
||||
assertTrue(group.getMaxPriority() == maxPriority);
|
||||
|
||||
if (maxPriority > Thread.MIN_PRIORITY) {
|
||||
group.setMaxPriority(maxPriority-1);
|
||||
assertTrue(group.getMaxPriority() == (maxPriority-1));
|
||||
}
|
||||
|
||||
group.setMaxPriority(maxPriority);
|
||||
assertTrue(group.getMaxPriority() == maxPriority);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testMaxPriority2() {
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
int maxPriority = group1.getMaxPriority();
|
||||
if (maxPriority > Thread.MIN_PRIORITY) {
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
assertTrue(group2.getMaxPriority() == maxPriority);
|
||||
|
||||
ThreadGroup group3 = new ThreadGroup(group2, "group3");
|
||||
assertTrue(group3.getMaxPriority() == maxPriority);
|
||||
|
||||
group1.setMaxPriority(Thread.MIN_PRIORITY);
|
||||
assertTrue(group1.getMaxPriority() == Thread.MIN_PRIORITY);
|
||||
assertTrue(group2.getMaxPriority() == Thread.MIN_PRIORITY);
|
||||
assertTrue(group3.getMaxPriority() == Thread.MIN_PRIORITY);
|
||||
group1.setMaxPriority(maxPriority);
|
||||
|
||||
assertTrue(group1.getMaxPriority() == maxPriority);
|
||||
assertTrue(group2.getMaxPriority() == maxPriority);
|
||||
assertTrue(group3.getMaxPriority() == maxPriority);
|
||||
|
||||
group2.setMaxPriority(Thread.MIN_PRIORITY);
|
||||
assertTrue(group1.getMaxPriority() == maxPriority);
|
||||
assertTrue(group2.getMaxPriority() == Thread.MIN_PRIORITY);
|
||||
assertTrue(group3.getMaxPriority() == Thread.MIN_PRIORITY);
|
||||
group2.setMaxPriority(maxPriority);
|
||||
|
||||
assertTrue(group1.getMaxPriority() == maxPriority);
|
||||
assertTrue(group2.getMaxPriority() == maxPriority);
|
||||
assertTrue(group3.getMaxPriority() == maxPriority);
|
||||
|
||||
group3.setMaxPriority(Thread.MIN_PRIORITY);
|
||||
assertTrue(group1.getMaxPriority() == maxPriority);
|
||||
assertTrue(group2.getMaxPriority() == maxPriority);
|
||||
assertTrue(group3.getMaxPriority() == Thread.MIN_PRIORITY);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void testMaxPriority3() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
if (group.getMaxPriority() > Thread.MIN_PRIORITY) {
|
||||
int maxPriority = Thread.MIN_PRIORITY + 1;
|
||||
group.setMaxPriority(maxPriority);
|
||||
assertTrue(group.getMaxPriority() == maxPriority);
|
||||
|
||||
Thread thread = new Thread(group, () -> { });
|
||||
int priority = thread.getPriority();
|
||||
|
||||
int expectedPriority = Math.min(Thread.currentThread().getPriority(), maxPriority);
|
||||
assertTrue(priority == expectedPriority);
|
||||
|
||||
thread.setPriority(Thread.MAX_PRIORITY);
|
||||
assertTrue(thread.getPriority() == maxPriority);
|
||||
|
||||
thread.setPriority(maxPriority);
|
||||
assertTrue(thread.getPriority() == maxPriority);
|
||||
|
||||
thread.setPriority(Thread.MIN_PRIORITY);
|
||||
assertTrue(thread.getPriority() == Thread.MIN_PRIORITY);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void testInterrupt1() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
assertTrue(group.activeCount() == 0);
|
||||
TestThread thread = TestThread.start(group, "foo");
|
||||
try {
|
||||
group.interrupt();
|
||||
} finally {
|
||||
thread.terminate();
|
||||
}
|
||||
assertTrue(thread.wasInterrupted());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testInterrupt2() {
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
TestThread thread1 = TestThread.start(group1, "foo");
|
||||
TestThread thread2 = TestThread.start(group2, "bar");
|
||||
try {
|
||||
group1.interrupt();
|
||||
} finally {
|
||||
thread1.terminate();
|
||||
thread2.terminate();
|
||||
}
|
||||
assertTrue(thread2.wasInterrupted());
|
||||
assertTrue(thread1.wasInterrupted());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testInterrupt3() {
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
TestThread thread1 = TestThread.start(group1, "foo");
|
||||
TestThread thread2 = TestThread.start(group2, "bar");
|
||||
try {
|
||||
group2.interrupt();
|
||||
} finally {
|
||||
thread1.terminate();
|
||||
thread2.terminate();
|
||||
}
|
||||
assertTrue(thread2.wasInterrupted());
|
||||
assertFalse(thread1.wasInterrupted());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDestroy() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
assertFalse(group.isDestroyed());
|
||||
group.destroy(); // does nothing
|
||||
assertFalse(group.isDestroyed());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDaemon() {
|
||||
boolean d = Thread.currentThread().getThreadGroup().isDaemon();
|
||||
|
||||
ThreadGroup group1 = new ThreadGroup("group1");
|
||||
assertTrue(group1.isDaemon() == d); // inherit
|
||||
|
||||
group1.setDaemon(true);
|
||||
assertTrue(group1.isDaemon());
|
||||
ThreadGroup group2 = new ThreadGroup(group1, "group2");
|
||||
assertTrue(group2.isDaemon()); // inherit
|
||||
|
||||
group1.setDaemon(false);
|
||||
assertFalse(group1.isDaemon());
|
||||
ThreadGroup group3 = new ThreadGroup(group1, "group2");
|
||||
assertFalse(group3.isDaemon()); // inherit
|
||||
}
|
||||
|
||||
@Test
|
||||
void testList() {
|
||||
ThreadGroup group = new ThreadGroup("foo");
|
||||
group.list();
|
||||
}
|
||||
|
||||
@Test
|
||||
void testNull1() {
|
||||
assertThrows(NullPointerException.class,
|
||||
() -> new ThreadGroup(null, "group"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testNull2() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
assertThrows(NullPointerException.class,
|
||||
() -> group.enumerate((Thread[]) null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testNull3() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
assertThrows(NullPointerException.class,
|
||||
() -> group.enumerate((Thread[]) null, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testNull4() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
assertThrows(NullPointerException.class,
|
||||
() -> group.enumerate((ThreadGroup[]) null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testNull5() {
|
||||
ThreadGroup group = new ThreadGroup("group");
|
||||
assertThrows(NullPointerException.class,
|
||||
() -> group.enumerate((ThreadGroup[]) null, false));
|
||||
}
|
||||
|
||||
private static <T> Set<T> toSet(T[] array, int len) {
|
||||
return Arrays.stream(array, 0, len).collect(Collectors.toSet());
|
||||
}
|
||||
|
||||
private static class TestThread extends Thread {
|
||||
TestThread(ThreadGroup group, String name) {
|
||||
super(group, name);
|
||||
}
|
||||
|
||||
static TestThread start(ThreadGroup group, String name) {
|
||||
TestThread thread = new TestThread(group, name);
|
||||
thread.start();
|
||||
return thread;
|
||||
}
|
||||
|
||||
private volatile boolean done;
|
||||
private volatile boolean interrupted;
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
if (Thread.currentThread() != this)
|
||||
throw new IllegalCallerException();
|
||||
while (!done) {
|
||||
LockSupport.park();
|
||||
if (Thread.interrupted()) {
|
||||
interrupted = true;
|
||||
}
|
||||
}
|
||||
if (Thread.interrupted()) {
|
||||
interrupted = true;
|
||||
}
|
||||
}
|
||||
|
||||
boolean wasInterrupted() {
|
||||
return interrupted;
|
||||
}
|
||||
|
||||
void terminate() {
|
||||
done = true;
|
||||
LockSupport.unpark(this);
|
||||
boolean interrupted = false;
|
||||
while (isAlive()) {
|
||||
try {
|
||||
Thread.sleep(10);
|
||||
} catch (InterruptedException e) {
|
||||
interrupted = true;
|
||||
}
|
||||
}
|
||||
if (interrupted) {
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue