engineering/java-topology
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

undefect. CWE-407 — 63 sites patched across 27 ecosystems

Browse source 
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:
russell@unturf.com 2026-03-26 17:11:57 -04:00
commit 0a580b313d
70422 changed files with 17213626 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

266
test/langtools/tools/javac/processing/model/util/elements/TestGetEnumConstantBody.java Normal file
View file

@ -0,0 +1,266 @@
/*
* Copyright (c) 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
* @bug 8312418
* @summary Test Elements.getEnumConstantBody
* @library /tools/javac/lib
* @build JavacTestingAbstractProcessor TestGetEnumConstantBody
* @compile -processor TestGetEnumConstantBody -XDshould.stop-at=FLOW TestGetEnumConstantBody.java
*/
import java.io.IOException;
import java.io.Writer;
import java.util.*;
import java.util.function.*;
import javax.annotation.processing.*;
import javax.lang.model.element.*;
import javax.lang.model.util.*;
import javax.lang.model.type.*;
/**
* Test basic workings of Elements.getEnumConstantBody
*/
public class TestGetEnumConstantBody extends JavacTestingAbstractProcessor {
private Elements vacuousElements = new VacuousElements();
private Set<Element> allElements = new HashSet<>();
private int round;
public boolean process(Set<? extends TypeElement> annotations,
RoundEnvironment roundEnv) {
allElements.addAll(roundEnv.getRootElements());
// In the innermost loop, examine the fields defined by the the nested classes
for (TypeElement typeRoot : ElementFilter.typesIn(allElements) ) {
if (typeRoot.getQualifiedName().contentEquals("Gen")) {
continue;
}
boolean elementSeen = false;
for (TypeElement typeElt : ElementFilter.typesIn(typeRoot.getEnclosedElements()) ) {
System.out.println("Testing type " + typeElt);
for (VariableElement field : ElementFilter.fieldsIn(typeElt.getEnclosedElements()) ) {
elementSeen = true;
System.out.println(field);
switch (field.getKind()) {
case FIELD -> expectIAE(field);
case ENUM_CONSTANT -> testEnumConstant(field, typeElt);
default -> throw new RuntimeException("Unexpected field kind seen");
}
}
}
if (!elementSeen) {
throw new RuntimeException("No elements seen.");
}
}
switch (round++) {
case 0:
try (Writer w = processingEnv.getFiler().createSourceFile("Cleaned").openWriter()) {
w.write("""
class Enclosing {
enum Cleaned {
@TestGetEnumConstantBody.ExpectedBinaryName("Enclosing$Cleaned$2")
A(new Object() {}) {
void test(Gen g) {
g.run();
}
},
B,
@TestGetEnumConstantBody.ExpectedBinaryName("Enclosing$Cleaned$4")
C(new Object() {}) {
};
private Cleaned() {}
private Cleaned(Object o) {}
}
}
""");
} catch (IOException ex) {
throw new RuntimeException(ex);
}
break;
case 1:
try (Writer w = processingEnv.getFiler().createSourceFile("Gen").openWriter()) {
w.write("""
public class Gen {
public void run() {}
}
""");
} catch (IOException ex) {
throw new RuntimeException(ex);
}
break;
}
return true;
}
private String computeExpectedBinaryName(VariableElement e) {
ExpectedBinaryName ebn = e.getAnnotation(ExpectedBinaryName.class);
return (ebn == null) ? null : ebn.value();
}
private void expectIAE(VariableElement variable) {
expectException0(() -> elements.getEnumConstantBody(variable),
"Expected exception not thrown");
expectException0(() -> vacuousElements.getEnumConstantBody(variable),
"Expected vacuous exception not thrown");
}
private void expectException0(Supplier<TypeElement> supplier, String message) {
try {
var typeElement = supplier.get();
messager.printError(message, typeElement);
} catch (IllegalArgumentException iae) {
; // Expected
}
}
void expectUOE(VariableElement field) {
try {
var result = vacuousElements.getEnumConstantBody(field);
messager.printError("Unexpected non-exceptional result returned", field);
} catch(UnsupportedOperationException uoe) {
; // Expected
}
}
private void testEnumConstant(VariableElement field,
TypeElement enclosingClass) {
String expectedBinaryName = computeExpectedBinaryName(field);
boolean expectEnumConstantBody = expectedBinaryName != null;
System.out.println("\tTesting enum constant " + field + " expected " + expectEnumConstantBody);
expectUOE(field);
TypeElement enumConstantBody = elements.getEnumConstantBody(field);
if (Objects.nonNull(enumConstantBody) != expectEnumConstantBody) {
messager.printError("Unexpected body value", field);
}
if (enumConstantBody != null) {
testEnumConstantBody(enumConstantBody, expectedBinaryName, enclosingClass);
}
System.out.println("\t constant body " + enumConstantBody);
}
/*
* From JLS 8.9.1:
*
* "The optional class body of an enum constant implicitly
* declares an anonymous class (15.9.5) that (i) is a direct
* subclass of the immediately enclosing enum class (8.1.4), and
* (ii) is final (8.1.1.2). The class body is governed by the
* usual rules of anonymous classes; in particular it cannot
* contain any constructors. Instance methods declared in these
* class bodies may be invoked outside the enclosing enum class
* only if they override accessible methods in the enclosing enum
* class (8.4.8)."
*/
private void testEnumConstantBody(TypeElement enumConstBody, String expectedBinaryName, TypeElement enumClass) {
if (enumConstBody.getNestingKind() != NestingKind.ANONYMOUS) {
messager.printError("Class body not an anonymous class", enumConstBody);
}
// Get the TypeElement for the direct superclass.
TypeElement superClass =
(TypeElement)(((DeclaredType)enumConstBody.getSuperclass()).asElement());
if (!superClass.equals(enumClass)) {
messager.printError("Class body is not a direct subclass of the enum", enumConstBody);
}
if (!enumConstBody.getModifiers().contains(Modifier.FINAL)) {
messager.printError("Modifier final missing on class body", enumConstBody);
}
if (!elements.getBinaryName(enumConstBody).contentEquals(expectedBinaryName)) {
messager.printError("Unexpected binary name, expected: " + expectedBinaryName +
", but was: " + elements.getBinaryName(enumConstBody), enumConstBody);
}
return;
}
@interface ExpectedBinaryName {
String value();
}
// Nested classes hosting a variety of different kinds of fields.
private static enum Body {
@ExpectedBinaryName("TestGetEnumConstantBody$Body$1")
GOLGI(true) {
public boolean isOrganelle() {return true;}
},
@ExpectedBinaryName("TestGetEnumConstantBody$Body$2")
HEAVENLY(true) {
public boolean isCelestial() {return true;}
};
private Body(boolean predicate) {
this.predicate = predicate;
}
private boolean predicate;
public static int field = 42;
public void method() {return;}
}
private static enum MetaSyntaxVar {
FOO("foo"),
BAR("bar");
private String lower;
private MetaSyntaxVar(String lower) {
this.lower = lower;
}
int BAZ = 0;
float QUUX = 0.1f;
}
// Instance and static fields.
public static class FieldHolder {
public static final int f1 = 1;
public static final String s = "s";
private Object data;
public FieldHolder(Object data) {
this.data = data;
}
}
}