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
284
test/jdk/java/lang/reflect/Nestmates/TestReflectionAPI.java
Normal file
284
test/jdk/java/lang/reflect/Nestmates/TestReflectionAPI.java
Normal file
|
|
@ -0,0 +1,284 @@
|
|||
/*
|
||||
* Copyright (c) 2017, 2024, 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
|
||||
* @bug 8046171
|
||||
* @summary Test the new nestmate reflection API
|
||||
* @compile TestReflectionAPI.java
|
||||
* PackagedNestHost.java
|
||||
* PackagedNestHost2.java
|
||||
* SampleNest.java
|
||||
* Hosts.java
|
||||
* InvalidNestHost.java
|
||||
*
|
||||
* @compile MemberNoHost.jcod
|
||||
* MemberMissingHost.jcod
|
||||
* MemberNotInstanceHost.jcod
|
||||
* MemberNotOurHost.jcod
|
||||
* MemberMalformedHost.jcod
|
||||
* MalformedHost.jcod
|
||||
* PackagedNestHost.jcod
|
||||
* PackagedNestHost2Member.jcod
|
||||
* PackagedNestHostMember.jcod
|
||||
* HostOfMemberNoHost.jcod
|
||||
* HostOfMemberMissingHost.jcod
|
||||
* HostOfMemberNotInstanceHost.jcod
|
||||
* HostOfMemberNotOurHost.jcod
|
||||
* HostOfMemberMalformedHost.jcod
|
||||
* HostWithSelfMember.jcod
|
||||
* HostWithDuplicateMembers.jcod
|
||||
*
|
||||
* @run main/othervm TestReflectionAPI
|
||||
*/
|
||||
|
||||
// We need a nest member class that is invalid for each of the possible reasons,
|
||||
// plus we need some external classes to test other failure modes.
|
||||
// For each nested class below there is a corresponding .jcod file which breaks one
|
||||
// of the rules regarding nest membership. For the package related tests we have
|
||||
// additional PackageNestHost*.java sources.
|
||||
// For testing getNestMembers we need an external host class that has a nested class
|
||||
// which we can form a jcod file from such that we get all the expected failure modes.
|
||||
// Note that all the .java files must be compiled in the same step, while all
|
||||
// .jcod files must be compiled in a later step.
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashSet;
|
||||
|
||||
public class TestReflectionAPI {
|
||||
|
||||
// Valid nest member
|
||||
static class Member {}
|
||||
|
||||
// Missing NestHost attribute
|
||||
static class MemberNoHost {}
|
||||
|
||||
// Missing NestHost class
|
||||
static class MemberMissingHost {}
|
||||
|
||||
// Invalid NestHost class (not instance class)
|
||||
static class MemberNotInstanceHost {
|
||||
Object[] oa; // create CP entry to use in jcod change
|
||||
}
|
||||
|
||||
// Valid but different NestHost class
|
||||
static class MemberNotOurHost {}
|
||||
|
||||
// Malformed NestHost class
|
||||
static class MemberMalformedHost {}
|
||||
|
||||
public static void main(String[] args) throws Throwable {
|
||||
// run tests twice so that failure reasons are
|
||||
// seen to remain the same
|
||||
for (int i = 0; i < 2; i++) {
|
||||
test_getNestHost();
|
||||
test_isNestmateOf();
|
||||
test_getNestMembers();
|
||||
}
|
||||
}
|
||||
|
||||
static void test_getNestHost() {
|
||||
Class<?> host = TestReflectionAPI.class;
|
||||
|
||||
// sampling of "good" checks
|
||||
|
||||
checkHost(host, host);
|
||||
checkHost(Member.class, host);
|
||||
Runnable r = new Runnable() { public void run() {}};
|
||||
checkHost(r.getClass(), host);
|
||||
|
||||
// all the "bad" classes should report themselves as their
|
||||
// own nest host - no exceptions should be thrown
|
||||
Class<?>[] allClasses = host.getDeclaredClasses();
|
||||
for (Class<?> c : allClasses) {
|
||||
if (c == Member.class)
|
||||
continue;
|
||||
checkHost(c, c);
|
||||
}
|
||||
checkHost(P1.PackagedNestHost.Member.class,
|
||||
P1.PackagedNestHost.Member.class);
|
||||
checkHost(P2.PackagedNestHost2.Member.class,
|
||||
P2.PackagedNestHost2.Member.class);
|
||||
|
||||
// test some 'special' classes
|
||||
checkHost(int.class, int.class); // primitive
|
||||
checkHost(Object[].class, Object[].class); // array
|
||||
checkHost(Thread.State.class, Thread.class); // enum
|
||||
checkHost(java.lang.annotation.Documented.class, // annotation
|
||||
java.lang.annotation.Documented.class);
|
||||
}
|
||||
|
||||
static void test_isNestmateOf() {
|
||||
Class<?> host = TestReflectionAPI.class;
|
||||
checkNestmates(host, host, true);
|
||||
checkNestmates(Member.class, host, true);
|
||||
Runnable r = new Runnable() { public void run() {}};
|
||||
checkNestmates(r.getClass(), host, true);
|
||||
|
||||
// all the "bad" classes should report themselves as their
|
||||
// own nest host - no exceptions should be thrown - so not
|
||||
// nestmates
|
||||
Class<?>[] allClasses = host.getDeclaredClasses();
|
||||
for (Class<?> c : allClasses) {
|
||||
if (c == Member.class)
|
||||
continue;
|
||||
checkNestmates(host, c, false);
|
||||
}
|
||||
|
||||
// 'special' classes
|
||||
checkNestmates(int.class, int.class, true); // primitive
|
||||
checkNestmates(int.class, long.class, false); // primitive
|
||||
checkNestmates(Object[].class, Object[].class, true); // array
|
||||
checkNestmates(Object[].class, int[].class, false); // array
|
||||
checkNestmates(Thread.State.class, Thread.class, true); // enum
|
||||
checkNestmates(java.lang.annotation.Documented.class, // annotation
|
||||
java.lang.annotation.Documented.class, true);
|
||||
}
|
||||
|
||||
static void test_getNestMembers() {
|
||||
// Sampling of "good" checks
|
||||
Class<?>[] good = { Object.class, Object[].class, int.class};
|
||||
checkSingletonNests(good);
|
||||
|
||||
// More thorough correctness check
|
||||
checkNest(SampleNest.class, SampleNest.nestedTypes(), false);
|
||||
|
||||
// Special cases - legal but not produced by javac
|
||||
checkNest(HostWithSelfMember.class,
|
||||
new Class<?>[] { HostWithSelfMember.class,
|
||||
HostWithSelfMember.Member.class },
|
||||
true);
|
||||
checkNest(HostWithDuplicateMembers.class,
|
||||
new Class<?>[] { HostWithDuplicateMembers.class,
|
||||
HostWithDuplicateMembers.Member1.class,
|
||||
HostWithDuplicateMembers.Member2.class },
|
||||
true);
|
||||
|
||||
// Hosts with only "bad" members
|
||||
Class<?>[] bad = {
|
||||
HostOfMemberNoHost.class,
|
||||
HostOfMemberMissingHost.class,
|
||||
HostOfMemberNotOurHost.class,
|
||||
HostOfMemberNotInstanceHost.class,
|
||||
HostOfMemberMalformedHost.class,
|
||||
};
|
||||
checkSingletonNests(bad);
|
||||
}
|
||||
|
||||
static void checkHost(Class<?> target, Class<?> expected) {
|
||||
System.out.println("Checking nest host of " + target.getName());
|
||||
Class<?> host = target.getNestHost();
|
||||
if (host != expected)
|
||||
throw new Error("Class " + target.getName() +
|
||||
" has nest host " + host.getName() +
|
||||
" but expected " + expected.getName());
|
||||
}
|
||||
|
||||
static void checkNestmates(Class<?> a, Class<?> b, boolean mates) {
|
||||
System.out.println("Checking if " + a.getName() +
|
||||
" isNestmateOf " + b.getName());
|
||||
|
||||
if (a.isNestmateOf(b) != mates)
|
||||
throw new Error("Class " + a.getName() + " is " +
|
||||
(mates ? "not " : "") +
|
||||
"a nestmate of " + b.getName() + " but should " +
|
||||
(mates ? "" : "not ") + "be");
|
||||
}
|
||||
|
||||
static Comparator<Class<?>> cmp = Comparator.comparing(Class::getName);
|
||||
|
||||
static void checkNest(Class<?> host, Class<?>[] unsortedTypes, boolean expectDups) {
|
||||
Class<?>[] members = host.getNestMembers();
|
||||
Arrays.sort(members, cmp);
|
||||
Class<?>[] nestedTypes = unsortedTypes.clone();
|
||||
Arrays.sort(nestedTypes, cmp);
|
||||
printMembers(host, members);
|
||||
printDeclared(host, nestedTypes);
|
||||
if (!Arrays.equals(members, nestedTypes)) {
|
||||
if (!expectDups) {
|
||||
throw new Error("Class " + host.getName() + " has different members " +
|
||||
"compared to declared classes");
|
||||
}
|
||||
else {
|
||||
// get rid of duplicates
|
||||
Class<?>[] memberSet =
|
||||
Arrays.stream(members).sorted(cmp).distinct().toArray(Class<?>[]::new);
|
||||
if (!Arrays.equals(memberSet, nestedTypes)) {
|
||||
throw new Error("Class " + host.getName() + " has different members " +
|
||||
"compared to declared classes, even after duplicate removal");
|
||||
}
|
||||
}
|
||||
}
|
||||
// verify all the relationships that must hold for nest members
|
||||
for (Class<?> a : members) {
|
||||
checkHost(a, host);
|
||||
checkNestmates(a, host, true);
|
||||
Class<?>[] aMembers = a.getNestMembers();
|
||||
if (aMembers[0] != host) {
|
||||
throw new Error("Class " + a.getName() + " getNestMembers()[0] = " +
|
||||
aMembers[0].getName() + " not " + host.getName());
|
||||
|
||||
}
|
||||
Arrays.sort(aMembers, cmp);
|
||||
if (!Arrays.equals(members, aMembers)) {
|
||||
throw new Error("Class " + a.getName() + " has different members " +
|
||||
"compared to host " + host.getName());
|
||||
}
|
||||
for (Class<?> b : members) {
|
||||
checkNestmates(a, b, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void checkSingletonNests(Class<?>[] classes) {
|
||||
for (Class<?> host : classes) {
|
||||
Class<?>[] members = host.getNestMembers();
|
||||
if (members.length != 1) {
|
||||
printMembers(host, members);
|
||||
throw new Error("Class " + host.getName() + " lists " + members.length
|
||||
+ " members instead of 1 (itself)");
|
||||
}
|
||||
if (members[0] != host) {
|
||||
printMembers(host, members);
|
||||
throw new Error("Class " + host.getName() + " lists " +
|
||||
members[0].getName() + " as member instead of itself");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void printMembers(Class<?> host, Class<?>[] members) {
|
||||
System.out.println("Class " + host.getName() + " has members: ");
|
||||
for (Class<?> c : members) {
|
||||
System.out.println(" - " + c.getName());
|
||||
}
|
||||
}
|
||||
|
||||
static void printDeclared(Class<?> host, Class<?>[] declared) {
|
||||
System.out.println("Class " + host.getName() + " has declared types: ");
|
||||
for (Class<?> c : declared) {
|
||||
System.out.println(" - " + c.getName());
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue