You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tomee.apache.org by db...@apache.org on 2021/05/02 16:05:40 UTC
[tomee-jakarta] branch master updated: Signature test fixes
This is an automated email from the ASF dual-hosted git repository.
dblevins pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tomee-jakarta.git
The following commit(s) were added to refs/heads/master by this push:
new 7c2086f Signature test fixes
7c2086f is described below
commit 7c2086fe7c3944f27db427ce55a9ff8d72192778
Author: David Blevins <da...@gmail.com>
AuthorDate: Sun May 2 08:41:10 2021 -0700
Signature test fixes
---
.../src/patch/java/jakarta/ejb/EJBContext.java | 27 +++
transform/src/patch/java/jakarta/ejb/Schedule.java | 33 +++
.../src/patch/java/jakarta/ejb/SessionContext.java | 15 ++
.../enterprise/inject/literal/InjectLiteral.java | 12 +
.../enterprise/inject/literal/NamedLiteral.java | 26 +++
.../inject/literal/QualifierLiteral.java | 12 +
.../inject/literal/SingletonLiteral.java | 12 +
.../jakarta/enterprise/util/AnnotationLiteral.java | 243 +++++++++++++++++++++
.../jakarta/enterprise/util/SecurityActions.java | 37 ++++
9 files changed, 417 insertions(+)
diff --git a/transform/src/patch/java/jakarta/ejb/EJBContext.java b/transform/src/patch/java/jakarta/ejb/EJBContext.java
new file mode 100644
index 0000000..c5862b2
--- /dev/null
+++ b/transform/src/patch/java/jakarta/ejb/EJBContext.java
@@ -0,0 +1,27 @@
+package jakarta.ejb;
+
+import java.util.*;
+import java.security.Principal;
+import jakarta.transaction.UserTransaction;
+
+public interface EJBContext {
+ EJBHome getEJBHome() throws IllegalStateException;
+
+ EJBLocalHome getEJBLocalHome() throws IllegalStateException;
+
+ Principal getCallerPrincipal() throws IllegalStateException;
+
+ boolean isCallerInRole(String roleName) throws IllegalStateException;
+
+ UserTransaction getUserTransaction() throws IllegalStateException;
+
+ void setRollbackOnly() throws IllegalStateException;
+
+ boolean getRollbackOnly() throws IllegalStateException;
+
+ TimerService getTimerService() throws IllegalStateException;
+
+ Object lookup(String name) throws IllegalArgumentException;
+
+ Map<String, Object> getContextData();
+}
diff --git a/transform/src/patch/java/jakarta/ejb/Schedule.java b/transform/src/patch/java/jakarta/ejb/Schedule.java
new file mode 100644
index 0000000..9ec4067
--- /dev/null
+++ b/transform/src/patch/java/jakarta/ejb/Schedule.java
@@ -0,0 +1,33 @@
+package jakarta.ejb;
+
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Target;
+import static java.lang.annotation.ElementType.*;
+import java.lang.annotation.Retention;
+import static java.lang.annotation.RetentionPolicy.*;
+
+@Target(METHOD)
+@Retention(RUNTIME)
+@Repeatable(Schedules.class)
+public @interface Schedule {
+
+ String second() default "0";
+
+ String minute() default "0";
+
+ String hour() default "0";
+
+ String dayOfMonth() default "*";
+
+ String month() default "*";
+
+ String dayOfWeek() default "*";
+
+ String year() default "*";
+
+ String timezone() default "";
+
+ String info() default "";
+
+ boolean persistent() default true;
+}
diff --git a/transform/src/patch/java/jakarta/ejb/SessionContext.java b/transform/src/patch/java/jakarta/ejb/SessionContext.java
new file mode 100644
index 0000000..751beb3
--- /dev/null
+++ b/transform/src/patch/java/jakarta/ejb/SessionContext.java
@@ -0,0 +1,15 @@
+
+package jakarta.ejb;
+
+public interface SessionContext extends EJBContext {
+ EJBLocalObject getEJBLocalObject() throws IllegalStateException;
+
+ EJBObject getEJBObject() throws IllegalStateException;
+
+ <T> T getBusinessObject(Class<T> businessInterface) throws IllegalStateException;
+
+ Class getInvokedBusinessInterface() throws IllegalStateException;
+
+ boolean wasCancelCalled() throws IllegalStateException;
+
+}
diff --git a/transform/src/patch/java/jakarta/enterprise/inject/literal/InjectLiteral.java b/transform/src/patch/java/jakarta/enterprise/inject/literal/InjectLiteral.java
new file mode 100644
index 0000000..172204e
--- /dev/null
+++ b/transform/src/patch/java/jakarta/enterprise/inject/literal/InjectLiteral.java
@@ -0,0 +1,12 @@
+package jakarta.enterprise.inject.literal;
+
+import jakarta.enterprise.util.AnnotationLiteral;
+import jakarta.inject.Inject;
+
+public final class InjectLiteral extends AnnotationLiteral<Inject> implements Inject {
+
+ public static final InjectLiteral INSTANCE = new InjectLiteral();
+
+ private static final long serialVersionUID = 1L;
+
+}
diff --git a/transform/src/patch/java/jakarta/enterprise/inject/literal/NamedLiteral.java b/transform/src/patch/java/jakarta/enterprise/inject/literal/NamedLiteral.java
new file mode 100644
index 0000000..6f1c5d1
--- /dev/null
+++ b/transform/src/patch/java/jakarta/enterprise/inject/literal/NamedLiteral.java
@@ -0,0 +1,26 @@
+package jakarta.enterprise.inject.literal;
+
+import jakarta.enterprise.util.AnnotationLiteral;
+import jakarta.inject.Named;
+
+public final class NamedLiteral extends AnnotationLiteral<Named> implements Named {
+
+ public static final Named INSTANCE = of("");
+
+ private static final long serialVersionUID = 1L;
+
+ private final String value;
+
+ public static NamedLiteral of(String value) {
+ return new NamedLiteral(value);
+ }
+
+ public String value() {
+ return value;
+ }
+
+ private NamedLiteral(String value) {
+ this.value = value;
+ }
+
+}
diff --git a/transform/src/patch/java/jakarta/enterprise/inject/literal/QualifierLiteral.java b/transform/src/patch/java/jakarta/enterprise/inject/literal/QualifierLiteral.java
new file mode 100644
index 0000000..f21d08d
--- /dev/null
+++ b/transform/src/patch/java/jakarta/enterprise/inject/literal/QualifierLiteral.java
@@ -0,0 +1,12 @@
+package jakarta.enterprise.inject.literal;
+
+import jakarta.enterprise.util.AnnotationLiteral;
+import jakarta.inject.Qualifier;
+
+public final class QualifierLiteral extends AnnotationLiteral<Qualifier> implements Qualifier {
+
+ public static final QualifierLiteral INSTANCE = new QualifierLiteral();
+
+ private static final long serialVersionUID = 1L;
+
+}
diff --git a/transform/src/patch/java/jakarta/enterprise/inject/literal/SingletonLiteral.java b/transform/src/patch/java/jakarta/enterprise/inject/literal/SingletonLiteral.java
new file mode 100644
index 0000000..b168ac7
--- /dev/null
+++ b/transform/src/patch/java/jakarta/enterprise/inject/literal/SingletonLiteral.java
@@ -0,0 +1,12 @@
+package jakarta.enterprise.inject.literal;
+
+import jakarta.enterprise.util.AnnotationLiteral;
+import jakarta.inject.Singleton;
+
+public final class SingletonLiteral extends AnnotationLiteral<Singleton> implements Singleton {
+
+ public static final SingletonLiteral INSTANCE = new SingletonLiteral();
+
+ private static final long serialVersionUID = 1L;
+
+}
diff --git a/transform/src/patch/java/jakarta/enterprise/util/AnnotationLiteral.java b/transform/src/patch/java/jakarta/enterprise/util/AnnotationLiteral.java
new file mode 100644
index 0000000..947d1cd
--- /dev/null
+++ b/transform/src/patch/java/jakarta/enterprise/util/AnnotationLiteral.java
@@ -0,0 +1,243 @@
+package jakarta.enterprise.util;
+
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+
+import jakarta.enterprise.event.Event;
+import jakarta.enterprise.inject.Instance;
+
+public abstract class AnnotationLiteral<T extends Annotation> implements Annotation, Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ private transient Class<T> annotationType;
+ private transient Method[] members;
+ private transient Integer cachedHashCode;
+
+ protected AnnotationLiteral() {
+ if (getMembers().length == 0) {
+ this.cachedHashCode = 0;
+ } else {
+ this.cachedHashCode = null;
+ }
+ }
+
+ private Method[] getMembers() {
+ if (members == null) {
+ members = SecurityActions.getDeclaredMethods(annotationType());
+ if (members.length > 0 && !annotationType().isAssignableFrom(this.getClass())) {
+ throw new RuntimeException(getClass() + " does not implement the annotation type with members "
+ + annotationType().getName());
+ }
+ }
+ return members;
+ }
+
+ private static Class<?> getAnnotationLiteralSubclass(Class<?> clazz) {
+ Class<?> superclass = clazz.getSuperclass();
+ if (superclass.equals(AnnotationLiteral.class)) {
+ return clazz;
+ } else if (superclass.equals(Object.class)) {
+ return null;
+ } else {
+ return (getAnnotationLiteralSubclass(superclass));
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private static <T> Class<T> getTypeParameter(Class<?> annotationLiteralSuperclass) {
+ Type type = annotationLiteralSuperclass.getGenericSuperclass();
+ if (type instanceof ParameterizedType) {
+ ParameterizedType parameterizedType = (ParameterizedType) type;
+ if (parameterizedType.getActualTypeArguments().length == 1) {
+ return (Class<T>) parameterizedType.getActualTypeArguments()[0];
+ }
+ }
+ return null;
+ }
+
+ public Class<? extends Annotation> annotationType() {
+ if (annotationType == null) {
+ Class<?> annotationLiteralSubclass = getAnnotationLiteralSubclass(this.getClass());
+ if (annotationLiteralSubclass == null) {
+ throw new RuntimeException(getClass() + " is not a subclass of AnnotationLiteral");
+ }
+ annotationType = getTypeParameter(annotationLiteralSubclass);
+ if (annotationType == null) {
+ throw new RuntimeException(getClass() + " does not specify the type parameter T of AnnotationLiteral<T>");
+ }
+ }
+ return annotationType;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder string = new StringBuilder();
+ string.append('@').append(annotationType().getName()).append('(');
+ for (int i = 0; i < getMembers().length; i++) {
+ string.append(getMembers()[i].getName()).append('=');
+ Object value = getMemberValue(getMembers()[i], this);
+ if (value instanceof boolean[]) {
+ appendInBraces(string, Arrays.toString((boolean[]) value));
+ } else if (value instanceof byte[]) {
+ appendInBraces(string, Arrays.toString((byte[]) value));
+ } else if (value instanceof short[]) {
+ appendInBraces(string, Arrays.toString((short[]) value));
+ } else if (value instanceof int[]) {
+ appendInBraces(string, Arrays.toString((int[]) value));
+ } else if (value instanceof long[]) {
+ appendInBraces(string, Arrays.toString((long[]) value));
+ } else if (value instanceof float[]) {
+ appendInBraces(string, Arrays.toString((float[]) value));
+ } else if (value instanceof double[]) {
+ appendInBraces(string, Arrays.toString((double[]) value));
+ } else if (value instanceof char[]) {
+ appendInBraces(string, Arrays.toString((char[]) value));
+ } else if (value instanceof String[]) {
+ String[] strings = (String[]) value;
+ String[] quoted = new String[strings.length];
+ for (int j = 0; j < strings.length; j++) {
+ quoted[j] = "\"" + strings[j] + "\"";
+ }
+ appendInBraces(string, Arrays.toString(quoted));
+ } else if (value instanceof Class<?>[]) {
+ Class<?>[] classes = (Class<?>[]) value;
+ String[] names = new String[classes.length];
+ for (int j = 0; j < classes.length; j++) {
+ names[j] = classes[j].getName() + ".class";
+ }
+ appendInBraces(string, Arrays.toString(names));
+ } else if (value instanceof Object[]) {
+ appendInBraces(string, Arrays.toString((Object[]) value));
+ } else if (value instanceof String) {
+ string.append('"').append(value).append('"');
+ } else if (value instanceof Class<?>) {
+ string.append(((Class<?>) value).getName()).append(".class");
+ } else {
+ string.append(value);
+ }
+ if (i < getMembers().length - 1) {
+ string.append(", ");
+ }
+ }
+ return string.append(')').toString();
+ }
+
+ private void appendInBraces(StringBuilder buf, String s) {
+ buf.append('{').append(s.substring(1, s.length() - 1)).append('}');
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (other == this) {
+ return true;
+ }
+ if (other == null) {
+ return false;
+ }
+ if (other instanceof Annotation) {
+ Annotation that = (Annotation) other;
+ if (this.annotationType().equals(that.annotationType())) {
+ for (Method member : getMembers()) {
+ Object thisValue = getMemberValue(member, this);
+ Object thatValue = getMemberValue(member, that);
+ if (thisValue instanceof byte[] && thatValue instanceof byte[]) {
+ if (!Arrays.equals((byte[]) thisValue, (byte[]) thatValue))
+ return false;
+ } else if (thisValue instanceof short[] && thatValue instanceof short[]) {
+ if (!Arrays.equals((short[]) thisValue, (short[]) thatValue))
+ return false;
+ } else if (thisValue instanceof int[] && thatValue instanceof int[]) {
+ if (!Arrays.equals((int[]) thisValue, (int[]) thatValue))
+ return false;
+ } else if (thisValue instanceof long[] && thatValue instanceof long[]) {
+ if (!Arrays.equals((long[]) thisValue, (long[]) thatValue))
+ return false;
+ } else if (thisValue instanceof float[] && thatValue instanceof float[]) {
+ if (!Arrays.equals((float[]) thisValue, (float[]) thatValue))
+ return false;
+ } else if (thisValue instanceof double[] && thatValue instanceof double[]) {
+ if (!Arrays.equals((double[]) thisValue, (double[]) thatValue))
+ return false;
+ } else if (thisValue instanceof char[] && thatValue instanceof char[]) {
+ if (!Arrays.equals((char[]) thisValue, (char[]) thatValue))
+ return false;
+ } else if (thisValue instanceof boolean[] && thatValue instanceof boolean[]) {
+ if (!Arrays.equals((boolean[]) thisValue, (boolean[]) thatValue))
+ return false;
+ } else if (thisValue instanceof Object[] && thatValue instanceof Object[]) {
+ if (!Arrays.equals((Object[]) thisValue, (Object[]) thatValue))
+ return false;
+ } else {
+ if (!thisValue.equals(thatValue))
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ if (cachedHashCode != null) {
+ return cachedHashCode;
+ } else {
+ int hashCode = 0;
+ for (Method member : getMembers()) {
+ Object value = getMemberValue(member, this);
+ int memberValueHashCode;
+ if (value instanceof boolean[]) {
+ memberValueHashCode = Arrays.hashCode((boolean[]) value);
+ } else if (value instanceof short[]) {
+ memberValueHashCode = Arrays.hashCode((short[]) value);
+ } else if (value instanceof int[]) {
+ memberValueHashCode = Arrays.hashCode((int[]) value);
+ } else if (value instanceof long[]) {
+ memberValueHashCode = Arrays.hashCode((long[]) value);
+ } else if (value instanceof float[]) {
+ memberValueHashCode = Arrays.hashCode((float[]) value);
+ } else if (value instanceof double[]) {
+ memberValueHashCode = Arrays.hashCode((double[]) value);
+ } else if (value instanceof byte[]) {
+ memberValueHashCode = Arrays.hashCode((byte[]) value);
+ } else if (value instanceof char[]) {
+ memberValueHashCode = Arrays.hashCode((char[]) value);
+ } else if (value instanceof Object[]) {
+ memberValueHashCode = Arrays.hashCode((Object[]) value);
+ } else {
+ memberValueHashCode = value.hashCode();
+ }
+ hashCode += memberNameHashCode ^ memberValueHashCode;
+ }
+ return hashCode;
+ }
+ }
+
+ private static Object getMemberValue(Method member, Annotation instance) {
+ Object value = invoke(member, instance);
+ if (value == null) {
+ throw new IllegalArgumentException("Annotation member value " + instance.getClass().getName() + "."
+ + member.getName() + " must not be null");
+ }
+ return value;
+ }
+
+ private static Object invoke(Method method, Object instance) {
+ try {
+ if (!method.isAccessible())
+ SecurityActions.setAccessible(method);
+ return method.invoke(instance);
+ } catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException e) {
+ throw new RuntimeException("Error checking value of member method " + method.getName() + " on "
+ + method.getDeclaringClass(), e);
+ }
+ }
+
+}
diff --git a/transform/src/patch/java/jakarta/enterprise/util/SecurityActions.java b/transform/src/patch/java/jakarta/enterprise/util/SecurityActions.java
new file mode 100644
index 0000000..5bebd59
--- /dev/null
+++ b/transform/src/patch/java/jakarta/enterprise/util/SecurityActions.java
@@ -0,0 +1,37 @@
+package jakarta.enterprise.util;
+
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+
+final class SecurityActions {
+
+ private SecurityActions() {
+
+ }
+
+ static void setAccessible(Method method) {
+ if (System.getSecurityManager() != null) {
+ AccessController.doPrivileged(
+ (PrivilegedAction<?>) () -> {
+ method.setAccessible(true);
+ return null;
+ }
+ );
+ } else {
+ method.setAccessible(true);
+ }
+ }
+
+
+ static Method[] getDeclaredMethods(Class<?> clazz) {
+ if (System.getSecurityManager() != null) {
+ return AccessController.doPrivileged(
+ (PrivilegedAction<Method[]>) () -> clazz.getDeclaredMethods()
+ );
+ } else {
+ return clazz.getDeclaredMethods();
+ }
+ }
+}