Skip to content

Commit b172aae

Browse files
AlanBatemanAlanBateman
committedMar 6, 2022
Extract SL tests from ThreadFlockTest
·
JEP-429-branchpoint
1 parent 0603f19 commit b172aae

File tree

2 files changed

+211
-156
lines changed

2 files changed

+211
-156
lines changed
 

‎test/jdk/jdk/internal/misc/ThreadFlock/ScopeLocalsTest.java

+206
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,206 @@
1+
/*
2+
* Copyright (c) 2021, 2022, Oracle and/or its affiliates. All rights reserved.
3+
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+
*
5+
* This code is free software; you can redistribute it and/or modify it
6+
* under the terms of the GNU General Public License version 2 only, as
7+
* published by the Free Software Foundation.
8+
*
9+
* This code is distributed in the hope that it will be useful, but WITHOUT
10+
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11+
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12+
* version 2 for more details (a copy is included in the LICENSE file that
13+
* accompanied this code).
14+
*
15+
* You should have received a copy of the GNU General Public License version
16+
* 2 along with this work; if not, write to the Free Software Foundation,
17+
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18+
*
19+
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20+
* or visit www.oracle.com if you need additional information or have any
21+
* questions.
22+
*/
23+
24+
/*
25+
* @test
26+
* @summary Test ThreadFlock with scope locals
27+
* @modules java.base/jdk.internal.misc
28+
* @modules jdk.incubator.concurrent
29+
* @compile --enable-preview -source ${jdk.version} ScopeLocalsTest.java
30+
* @run testng/othervm --enable-preview ScopeLocalsTest
31+
*/
32+
33+
import java.util.*;
34+
import java.util.concurrent.*;
35+
import java.util.concurrent.atomic.AtomicReference;
36+
import jdk.internal.misc.ThreadFlock;
37+
import jdk.incubator.concurrent.ScopeLocal;
38+
import jdk.incubator.concurrent.StructureViolationException;
39+
40+
import org.testng.annotations.DataProvider;
41+
import org.testng.annotations.Test;
42+
import static org.testng.Assert.*;
43+
44+
@Test
45+
public class ScopeLocalsTest {
46+
47+
@DataProvider(name = "factories")
48+
public Object[][] factories() {
49+
var defaultThreadFactory = Executors.defaultThreadFactory();
50+
var virtualThreadFactory = Thread.ofVirtual().factory();
51+
return new Object[][]{
52+
{ defaultThreadFactory, },
53+
{ virtualThreadFactory, },
54+
};
55+
}
56+
57+
/**
58+
* Test inheritance of scope-local bindings.
59+
*/
60+
@Test(dataProvider = "factories")
61+
public void testInheritsScopeLocals(ThreadFactory factory) throws Exception {
62+
ScopeLocal<String> NAME = ScopeLocal.newInstance();
63+
String value = ScopeLocal.where(NAME, "fred").call(() -> {
64+
var result = new AtomicReference<String>();
65+
try (var flock = ThreadFlock.open(null)) {
66+
Thread thread = factory.newThread(() -> {
67+
// child
68+
result.set(NAME.get());
69+
});
70+
flock.start(thread);
71+
}
72+
return result.get();
73+
});
74+
assertEquals(value, "fred");
75+
}
76+
77+
/**
78+
* Test exiting a scope local operation should close nested thread flocks.
79+
*/
80+
public void testStructureViolation1() {
81+
ScopeLocal<String> name = ScopeLocal.newInstance();
82+
class Box {
83+
ThreadFlock flock1;
84+
ThreadFlock flock2;
85+
}
86+
var box = new Box();
87+
try {
88+
ScopeLocal.where(name, "x1").run(() -> {
89+
box.flock1 = ThreadFlock.open(null);
90+
box.flock2 = ThreadFlock.open(null);
91+
});
92+
assertTrue(false);
93+
} catch (StructureViolationException expected) { }
94+
assertTrue(box.flock1.isClosed());
95+
assertTrue(box.flock2.isClosed());
96+
}
97+
98+
/**
99+
* Test closing a thread flock with enclosing scope local operations and
100+
* thread flocks. This test closes enclosing flock1.
101+
*/
102+
public void testStructureViolation2() {
103+
ScopeLocal<String> name = ScopeLocal.newInstance();
104+
try (var flock1 = ThreadFlock.open("flock1")) {
105+
ScopeLocal.where(name, "x1").run(() -> {
106+
try (var flock2 = ThreadFlock.open("flock2")) {
107+
ScopeLocal.where(name, "x2").run(() -> {
108+
try (var flock3 = ThreadFlock.open("flock3")) {
109+
ScopeLocal.where(name, "x3").run(() -> {
110+
var flock4 = ThreadFlock.open("flock4");
111+
112+
try {
113+
flock1.close();
114+
assertTrue(false);
115+
} catch (StructureViolationException expected) { }
116+
117+
assertTrue(flock1.isClosed());
118+
assertTrue(flock2.isClosed());
119+
assertTrue(flock3.isClosed());
120+
assertTrue(flock4.isClosed());
121+
122+
});
123+
}
124+
});
125+
}
126+
});
127+
}
128+
}
129+
130+
/**
131+
* Test closing a thread flock with enclosing scope local operations and
132+
* thread flocks. This test closes enclosing flock2.
133+
*/
134+
public void testStructureViolation3() {
135+
ScopeLocal<String> name = ScopeLocal.newInstance();
136+
try (var flock1 = ThreadFlock.open("flock1")) {
137+
ScopeLocal.where(name, "x1").run(() -> {
138+
try (var flock2 = ThreadFlock.open("flock2")) {
139+
ScopeLocal.where(name, "x2").run(() -> {
140+
try (var flock3 = ThreadFlock.open("flock3")) {
141+
ScopeLocal.where(name, "x3").run(() -> {
142+
var flock4 = ThreadFlock.open("flock4");
143+
144+
try {
145+
flock2.close();
146+
assertTrue(false);
147+
} catch (StructureViolationException expected) { }
148+
149+
assertFalse(flock1.isClosed());
150+
assertTrue(flock2.isClosed());
151+
assertTrue(flock3.isClosed());
152+
assertTrue(flock4.isClosed());
153+
});
154+
}
155+
});
156+
}
157+
});
158+
}
159+
}
160+
161+
/**
162+
* Test closing a thread flock with enclosing scope local operations and
163+
* thread flocks. This test closes enclosing flock3.
164+
*/
165+
public void testStructureViolation4() {
166+
ScopeLocal<String> name = ScopeLocal.newInstance();
167+
try (var flock1 = ThreadFlock.open("flock1")) {
168+
ScopeLocal.where(name, "x1").run(() -> {
169+
try (var flock2 = ThreadFlock.open("flock2")) {
170+
ScopeLocal.where(name, "x2").run(() -> {
171+
try (var flock3 = ThreadFlock.open("flock3")) {
172+
ScopeLocal.where(name, "x3").run(() -> {
173+
var flock4 = ThreadFlock.open("flock4");
174+
175+
try {
176+
flock3.close();
177+
assertTrue(false);
178+
} catch (StructureViolationException expected) { }
179+
180+
assertFalse(flock1.isClosed());
181+
assertFalse(flock2.isClosed());
182+
assertTrue(flock3.isClosed());
183+
assertTrue(flock4.isClosed());
184+
});
185+
}
186+
});
187+
}
188+
});
189+
}
190+
}
191+
192+
/**
193+
* Test that start throws StructureViolationException if scope-local bindings
194+
* have changed.
195+
*/
196+
@Test(dataProvider = "factories")
197+
public void testStructureViolation5(ThreadFactory factory) throws Exception {
198+
ScopeLocal<String> NAME = ScopeLocal.newInstance();
199+
try (var flock = ThreadFlock.open(null)) {
200+
ScopeLocal.where(NAME, "fred").run(() -> {
201+
Thread thread = factory.newThread(() -> { });
202+
expectThrows(StructureViolationException.class, () -> flock.start(thread));
203+
});
204+
}
205+
}
206+
}

‎test/jdk/jdk/internal/misc/ThreadFlock/ThreadFlockTest.java

+5-156
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
2+
* Copyright (c) 2021, 2022, Oracle and/or its affiliates. All rights reserved.
33
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
44
*
55
* This code is free software; you can redistribute it and/or modify it
@@ -25,7 +25,6 @@
2525
* @test
2626
* @summary Basic tests for ThreadFlock
2727
* @modules java.base/jdk.internal.misc
28-
* @modules jdk.incubator.concurrent
2928
* @compile --enable-preview -source ${jdk.version} ThreadFlockTest.java
3029
* @run testng/othervm --enable-preview ThreadFlockTest
3130
*/
@@ -38,8 +37,6 @@
3837
import java.util.concurrent.atomic.AtomicReference;
3938
import java.util.stream.Collectors;
4039
import jdk.internal.misc.ThreadFlock;
41-
import jdk.incubator.concurrent.ScopeLocal;
42-
import jdk.incubator.concurrent.StructureViolationException;
4340

4441
import org.testng.annotations.AfterClass;
4542
import org.testng.annotations.BeforeClass;
@@ -358,26 +355,6 @@ private void testStartConfined(ThreadFlock flock,
358355
}
359356
}
360357

361-
/**
362-
* Test that start inherits scope-local bindings.
363-
*/
364-
@Test(dataProvider = "factories")
365-
public void testStartInheritsScopeLocals(ThreadFactory factory) throws Exception {
366-
ScopeLocal<String> NAME = ScopeLocal.newInstance();
367-
String value = ScopeLocal.where(NAME, "fred").call(() -> {
368-
var result = new AtomicReference<String>();
369-
try (var flock = ThreadFlock.open(null)) {
370-
Thread thread = factory.newThread(() -> {
371-
// child
372-
result.set(NAME.get());
373-
});
374-
flock.start(thread);
375-
}
376-
return result.get();
377-
});
378-
assertEquals(value, "fred");
379-
}
380-
381358
/**
382359
* Test awaitAll with no threads.
383360
*/
@@ -950,149 +927,21 @@ private void testShutdownConfined(ThreadFlock flock,
950927
/**
951928
* Test that closing an enclosing thread flock closes a nested thread flocks.
952929
*/
953-
public void testStructureViolation1() {
930+
public void testStructureViolation() {
954931
try (var flock1 = ThreadFlock.open("flock1")) {
955932
try (var flock2 = ThreadFlock.open("flock2")) {
956933
try {
957934
flock1.close();
958935
assertTrue(false);
959-
} catch (StructureViolationException expected) { }
936+
} catch (RuntimeException e) {
937+
assertTrue(e.toString().contains("Structure"));
938+
}
960939
assertTrue(flock1.isClosed());
961940
assertTrue(flock2.isClosed());
962941
}
963942
}
964943
}
965944

966-
/**
967-
* Test exiting a scope local operation should close nested thread flocks.
968-
*/
969-
public void testStructureViolation2() {
970-
ScopeLocal<String> name = ScopeLocal.newInstance();
971-
class Box {
972-
ThreadFlock flock1;
973-
ThreadFlock flock2;
974-
}
975-
var box = new Box();
976-
try {
977-
ScopeLocal.where(name, "x1").run(() -> {
978-
box.flock1 = ThreadFlock.open(null);
979-
box.flock2 = ThreadFlock.open(null);
980-
});
981-
assertTrue(false);
982-
} catch (StructureViolationException expected) { }
983-
assertTrue(box.flock1.isClosed());
984-
assertTrue(box.flock2.isClosed());
985-
}
986-
987-
/**
988-
* Test closing a thread flock with enclosing scope local operations and
989-
* thread flocks. This test closes enclosing flock1.
990-
*/
991-
public void testStructureViolation3() {
992-
ScopeLocal<String> name = ScopeLocal.newInstance();
993-
try (var flock1 = ThreadFlock.open("flock1")) {
994-
ScopeLocal.where(name, "x1").run(() -> {
995-
try (var flock2 = ThreadFlock.open("flock2")) {
996-
ScopeLocal.where(name, "x2").run(() -> {
997-
try (var flock3 = ThreadFlock.open("flock3")) {
998-
ScopeLocal.where(name, "x3").run(() -> {
999-
var flock4 = ThreadFlock.open("flock4");
1000-
1001-
try {
1002-
flock1.close();
1003-
assertTrue(false);
1004-
} catch (StructureViolationException expected) { }
1005-
1006-
assertTrue(flock1.isClosed());
1007-
assertTrue(flock2.isClosed());
1008-
assertTrue(flock3.isClosed());
1009-
assertTrue(flock4.isClosed());
1010-
1011-
});
1012-
}
1013-
});
1014-
}
1015-
});
1016-
}
1017-
}
1018-
1019-
/**
1020-
* Test closing a thread flock with enclosing scope local operations and
1021-
* thread flocks. This test closes enclosing flock2.
1022-
*/
1023-
public void testStructureViolation4() {
1024-
ScopeLocal<String> name = ScopeLocal.newInstance();
1025-
try (var flock1 = ThreadFlock.open("flock1")) {
1026-
ScopeLocal.where(name, "x1").run(() -> {
1027-
try (var flock2 = ThreadFlock.open("flock2")) {
1028-
ScopeLocal.where(name, "x2").run(() -> {
1029-
try (var flock3 = ThreadFlock.open("flock3")) {
1030-
ScopeLocal.where(name, "x3").run(() -> {
1031-
var flock4 = ThreadFlock.open("flock4");
1032-
1033-
try {
1034-
flock2.close();
1035-
assertTrue(false);
1036-
} catch (StructureViolationException expected) { }
1037-
1038-
assertFalse(flock1.isClosed());
1039-
assertTrue(flock2.isClosed());
1040-
assertTrue(flock3.isClosed());
1041-
assertTrue(flock4.isClosed());
1042-
});
1043-
}
1044-
});
1045-
}
1046-
});
1047-
}
1048-
}
1049-
1050-
/**
1051-
* Test closing a thread flock with enclosing scope local operations and
1052-
* thread flocks. This test closes enclosing flock3.
1053-
*/
1054-
public void testStructureViolation5() {
1055-
ScopeLocal<String> name = ScopeLocal.newInstance();
1056-
try (var flock1 = ThreadFlock.open("flock1")) {
1057-
ScopeLocal.where(name, "x1").run(() -> {
1058-
try (var flock2 = ThreadFlock.open("flock2")) {
1059-
ScopeLocal.where(name, "x2").run(() -> {
1060-
try (var flock3 = ThreadFlock.open("flock3")) {
1061-
ScopeLocal.where(name, "x3").run(() -> {
1062-
var flock4 = ThreadFlock.open("flock4");
1063-
1064-
try {
1065-
flock3.close();
1066-
assertTrue(false);
1067-
} catch (StructureViolationException expected) { }
1068-
1069-
assertFalse(flock1.isClosed());
1070-
assertFalse(flock2.isClosed());
1071-
assertTrue(flock3.isClosed());
1072-
assertTrue(flock4.isClosed());
1073-
});
1074-
}
1075-
});
1076-
}
1077-
});
1078-
}
1079-
}
1080-
1081-
/**
1082-
* Test that start throws StructureViolationException if scope-local bindings
1083-
* have changed.
1084-
*/
1085-
@Test(dataProvider = "factories")
1086-
public void testStructureViolation6(ThreadFactory factory) throws Exception {
1087-
ScopeLocal<String> NAME = ScopeLocal.newInstance();
1088-
try (var flock = ThreadFlock.open(null)) {
1089-
ScopeLocal.where(NAME, "fred").run(() -> {
1090-
Thread thread = factory.newThread(() -> { });
1091-
expectThrows(StructureViolationException.class, () -> flock.start(thread));
1092-
});
1093-
}
1094-
}
1095-
1096945
/**
1097946
* Test Thread exiting with an open flock. The exiting thread should close the flock.
1098947
*/

0 commit comments

Comments
 (0)
Please sign in to comment.