Skip to content

Commit dfdb2de

Browse files
liachliach
committed
Some omissions
1 parent ac47d48 commit dfdb2de

2 files changed

Lines changed: 48 additions & 57 deletions

File tree

‎test/jdk/java/lang/invoke/AccessControlTest.java‎

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -71,7 +71,7 @@ public LookupCase(Lookup lookup) {
7171
this.prevLookupClass = lookup.previousLookupClass();
7272
this.lookupModes = lookup.lookupModes();
7373

74-
Assertions.assertTrue(lookupString().equals(lookup.toString()));
74+
assertEquals(lookupString(), lookup.toString());
7575
numberOf(lookupClass().getClassLoader()); // assign CL#
7676
}
7777
public LookupCase(Class<?> lookupClass, Class<?> prevLookupClass, int lookupModes) {
@@ -98,7 +98,7 @@ public int compareTo(LookupCase that) {
9898
int cmp = c1.getName().compareTo(c2.getName());
9999
if (cmp != 0) return cmp;
100100
cmp = numberOf(c1.getClassLoader()) - numberOf(c2.getClassLoader());
101-
Assertions.assertTrue(cmp != 0);
101+
assertNotEquals(0, cmp);
102102
return cmp;
103103
} else if (p1 != p2){
104104
if (p1 == null)
@@ -108,7 +108,7 @@ else if (p2 == null)
108108
int cmp = p1.getName().compareTo(p2.getName());
109109
if (cmp != 0) return cmp;
110110
cmp = numberOf(p1.getClassLoader()) - numberOf(p2.getClassLoader());
111-
Assertions.assertTrue(cmp != 0);
111+
assertNotEquals(0, cmp);
112112
return cmp;
113113
}
114114
return -(this.lookupModes() - that.lookupModes());
@@ -253,16 +253,16 @@ public LookupCase in(Class<?> c2) {
253253
changed |= (PRIVATE|PROTECTED); // [A5]
254254
}
255255
if (sameClass) {
256-
Assertions.assertTrue(changed == 0); // [A11] (no deprivation if same class)
256+
assertEquals(0, changed); // [A11] (no deprivation if same class)
257257
}
258258

259-
if (accessible) Assertions.assertTrue((changed & PUBLIC) == 0);
259+
if (accessible) assertEquals(0, changed & PUBLIC);
260260
int modes2 = modes1 & ~changed;
261261
Class<?> plc = (m1 == m2) ? prevLookupClass() : c1; // [A9] [A10]
262262
if ((modes1 & UNCONDITIONAL) != 0) plc = null; // [A8]
263263
LookupCase l2 = new LookupCase(c2, plc, modes2);
264-
Assertions.assertTrue(l2.lookupClass() == c2); // [A1]
265-
Assertions.assertTrue((modes1 | modes2) == modes1); // [A1-a] (no elevation of access)
264+
assertSame(l2.lookupClass(), c2); // [A1]
265+
assertEquals(modes1, modes1 | modes2); // [A1-a] (no elevation of access)
266266
Assertions.assertTrue(l2.prevLookupClass() == null || (modes2 & MODULE) == 0);
267267
return l2;
268268
}
@@ -282,7 +282,7 @@ LookupCase dropLookupMode(int modeToDrop) {
282282
}
283283
if (newModes == oldModes) return this; // return self if no change
284284
LookupCase l2 = new LookupCase(lookupClass(), prevLookupClass(), newModes);
285-
Assertions.assertTrue((oldModes | newModes) == oldModes); // [A2] (no elevation of access)
285+
assertEquals(oldModes, oldModes | newModes); // [A2] (no elevation of access)
286286
Assertions.assertTrue(l2.prevLookupClass() == null || (newModes & MODULE) == 0);
287287
return l2;
288288
}
@@ -333,7 +333,7 @@ && isModuleAccessible(c2)
333333
&& Modifier.isPublic(m.getModifiers());
334334
}
335335

336-
Assertions.assertTrue(m1 == m2 && prevLookupClass == null);
336+
assertNull(prevLookupClass);
337337

338338
if (!willAccessClass(c2, false))
339339
return false;
@@ -382,7 +382,7 @@ && isModuleAccessible(c2)
382382
&& Modifier.isPublic(c2.getModifiers());
383383
}
384384

385-
Assertions.assertTrue(m1 == m2 && prevLookupClass == null);
385+
assertNull(prevLookupClass);
386386

387387
LookupCase lc = this.in(c2);
388388
int modes1 = lc.lookupModes();
@@ -411,7 +411,7 @@ private static Class<?> topLevelClass(Class<?> cls) {
411411
Class<?> c = cls;
412412
for (Class<?> ec; (ec = c.getEnclosingClass()) != null; )
413413
c = ec;
414-
Assertions.assertTrue(c.getEnclosingClass() == null);
414+
assertNull(c.getEnclosingClass());
415415
Assertions.assertTrue(c == cls || cls.getEnclosingClass() != null);
416416
return c;
417417
}
@@ -445,10 +445,10 @@ private void addLookupEdge(LookupCase l1, Class<?> c2, LookupCase l2, int dropAc
445445
if (edges == null) CASE_EDGES.put(l2, edges = new TreeSet<>());
446446
if (edges.add(l1)) {
447447
Class<?> c1 = l1.lookupClass();
448-
Assertions.assertTrue(l2.lookupClass() == c2); // [A1]
448+
assertSame(l2.lookupClass(), c2); // [A1]
449449
int m1 = l1.lookupModes();
450450
int m2 = l2.lookupModes();
451-
Assertions.assertTrue((m1 | m2) == m1); // [A2] (no elevation of access)
451+
assertEquals(m1, (m1 | m2)); // [A2] (no elevation of access)
452452
LookupCase expect = dropAccess == 0 ? l1.in(c2) : l1.in(c2).dropLookupMode(dropAccess);
453453
if (!expect.equals(l2))
454454
System.out.println("*** expect "+l1+" => "+expect+" but got "+l2);
@@ -584,7 +584,7 @@ static Method targetMethod(Class<?> targetClass, int targetAccess, MethodType me
584584
assertEquals(methodType.returnType(), method.getReturnType());
585585
int haveMods = method.getModifiers();
586586
Assertions.assertTrue(Modifier.isStatic(haveMods));
587-
Assertions.assertTrue(targetAccess == fixMods(haveMods));
587+
assertEquals(targetAccess, fixMods(haveMods));
588588
return method;
589589
} catch (NoSuchMethodException ex) {
590590
throw new AssertionError(methodName, ex);
@@ -606,7 +606,7 @@ static String accessName(int acc) {
606606
case PACKAGE: return "pkg_in_";
607607
case PRIVATE: return "pri_in_";
608608
}
609-
Assertions.assertTrue(false);
609+
Assertions.fail();
610610
return "?";
611611
}
612612
private static final int[] ACCESS_CASES = {

‎test/jdk/java/lang/invoke/VarHandles/VarHandleTestReflection.java‎

Lines changed: 33 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -57,14 +57,12 @@ static VarHandle handle() throws Exception {
5757
@ParameterizedTest
5858
@MethodSource("accessModesProvider")
5959
public void methodInvocationArgumentMismatch(VarHandle.AccessMode accessMode) throws Exception {
60-
Assertions.assertThrows(IllegalArgumentException.class, () -> {
61-
VarHandle v = handle();
60+
VarHandle v = handle();
6261

63-
// Try a reflective invoke using a Method, with no arguments
62+
// Try a reflective invoke using a Method, with no arguments
6463

65-
Method vhm = VarHandle.class.getMethod(accessMode.methodName(), Object[].class);
66-
vhm.invoke(v, new Object[]{});
67-
});
64+
Method vhm = VarHandle.class.getMethod(accessMode.methodName(), Object[].class);
65+
Assertions.assertThrows(IllegalArgumentException.class, () -> vhm.invoke(v, new Object[]{}));
6866
}
6967

7068
@ParameterizedTest
@@ -76,76 +74,69 @@ public void methodInvocationMatchingArguments(VarHandle.AccessMode accessMode) t
7674

7775
Method vhm = VarHandle.class.getMethod(accessMode.methodName(), Object[].class);
7876
Object arg = new Object[0];
79-
try {
80-
vhm.invoke(v, arg);
81-
} catch (InvocationTargetException e) {
82-
if (!(e.getCause() instanceof UnsupportedOperationException)) {
83-
throw new RuntimeException("expected UnsupportedOperationException but got: "
84-
+ e.getCause().getClass().getName(), e);
85-
}
77+
var e = Assertions.assertThrows(InvocationTargetException.class, () -> vhm.invoke(v, arg));
78+
if (!(e.getCause() instanceof UnsupportedOperationException)) {
79+
throw new RuntimeException("expected UnsupportedOperationException but got: "
80+
+ e.getCause().getClass().getName(), e);
8681
}
8782
}
8883

8984
@ParameterizedTest
9085
@MethodSource("accessModesProvider")
9186
public void methodHandleInvoke(VarHandle.AccessMode accessMode) throws Throwable {
92-
Assertions.assertThrows(UnsupportedOperationException.class, () -> {
93-
VarHandle v = handle();
87+
VarHandle v = handle();
9488

95-
// Try a reflective invoke using a MethodHandle
89+
// Try a reflective invoke using a MethodHandle
9690

97-
MethodHandle mh = MethodHandles.lookup().unreflect(
98-
VarHandle.class.getMethod(accessMode.methodName(), Object[].class));
99-
// Use invoke to avoid WrongMethodTypeException for
100-
// non-signature-polymorphic return types
91+
MethodHandle mh = MethodHandles.lookup().unreflect(
92+
VarHandle.class.getMethod(accessMode.methodName(), Object[].class));
93+
// Use invoke to avoid WrongMethodTypeException for
94+
// non-signature-polymorphic return types
95+
Assertions.assertThrows(UnsupportedOperationException.class, () -> {
10196
Object o = (Object) mh.invoke(v, new Object[]{});
10297
});
10398
}
10499

105100
@ParameterizedTest
106101
@MethodSource("accessModesProvider")
107102
public void methodInvocationFromMethodInfo(VarHandle.AccessMode accessMode) throws Exception {
108-
Assertions.assertThrows(IllegalArgumentException.class, () -> {
109-
VarHandle v = handle();
103+
VarHandle v = handle();
110104

111-
// Try a reflective invoke using a Method obtained from cracking
112-
// a MethodHandle
105+
// Try a reflective invoke using a Method obtained from cracking
106+
// a MethodHandle
113107

114-
MethodHandle mh = MethodHandles.lookup().unreflect(
115-
VarHandle.class.getMethod(accessMode.methodName(), Object[].class));
116-
MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh);
117-
Method im = info.reflectAs(Method.class, MethodHandles.lookup());
108+
MethodHandle mh = MethodHandles.lookup().unreflect(
109+
VarHandle.class.getMethod(accessMode.methodName(), Object[].class));
110+
MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh);
111+
Method im = info.reflectAs(Method.class, MethodHandles.lookup());
112+
Assertions.assertThrows(IllegalArgumentException.class, () -> {
118113
im.invoke(v, new Object[]{});
119114
});
120115
}
121116

122117
@ParameterizedTest
123118
@MethodSource("accessModesProvider")
124119
public void reflectAsFromVarHandleInvoker(VarHandle.AccessMode accessMode) throws Exception {
125-
Assertions.assertThrows(IllegalArgumentException.class, () -> {
126-
VarHandle v = handle();
120+
VarHandle v = handle();
127121

128-
MethodHandle mh = MethodHandles.varHandleInvoker(
129-
accessMode, v.accessModeType(accessMode));
122+
MethodHandle mh = MethodHandles.varHandleInvoker(
123+
accessMode, v.accessModeType(accessMode));
130124

131-
MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh);
125+
MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh);
132126

133-
info.reflectAs(Method.class, MethodHandles.lookup());
134-
});
127+
Assertions.assertThrows(IllegalArgumentException.class, () -> info.reflectAs(Method.class, MethodHandles.lookup()));
135128
}
136129

137130
@ParameterizedTest
138131
@MethodSource("accessModesProvider")
139132
public void reflectAsFromFindVirtual(VarHandle.AccessMode accessMode) throws Exception {
140-
Assertions.assertThrows(IllegalArgumentException.class, () -> {
141-
VarHandle v = handle();
133+
VarHandle v = handle();
142134

143-
MethodHandle mh = MethodHandles.publicLookup().findVirtual(
144-
VarHandle.class, accessMode.methodName(), v.accessModeType(accessMode));
135+
MethodHandle mh = MethodHandles.publicLookup().findVirtual(
136+
VarHandle.class, accessMode.methodName(), v.accessModeType(accessMode));
145137

146-
MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh);
138+
MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh);
147139

148-
info.reflectAs(Method.class, MethodHandles.lookup());
149-
});
140+
Assertions.assertThrows(IllegalArgumentException.class, () -> info.reflectAs(Method.class, MethodHandles.lookup()));
150141
}
151142
}

0 commit comments

Comments
 (0)