You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openwebbeans.apache.org by st...@apache.org on 2019/09/11 14:31:07 UTC
[openwebbeans] branch master updated (e19de31 -> 242a341)
This is an automated email from the ASF dual-hosted git repository.
struberg pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/openwebbeans.git.
from e19de31 OWB-1297 drop parent creational context from Instance
new f8847cc OWB-1297 remove parentCreationalContext from the InstanceImpl alltogether
new 242a341 OWB-1297 adding unit test for InjectionPoint for Instance<T>
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../webbeans/inject/instance/InstanceImpl.java | 11 +-
.../apache/webbeans/portable/InstanceProducer.java | 2 +-
.../test/instance/InstanceInjectionPointTest.java | 116 +++++++++++++++++++++
3 files changed, 120 insertions(+), 9 deletions(-)
create mode 100644 webbeans-impl/src/test/java/org/apache/webbeans/test/instance/InstanceInjectionPointTest.java
[openwebbeans] 01/02: OWB-1297 remove parentCreationalContext from
the InstanceImpl alltogether
Posted by st...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
struberg pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/openwebbeans.git
commit f8847cc339437e87238518a9b7488b868708b6ec
Author: Mark Struberg <st...@apache.org>
AuthorDate: Wed Sep 11 14:28:19 2019 +0200
OWB-1297 remove parentCreationalContext from the InstanceImpl alltogether
---
.../org/apache/webbeans/inject/instance/InstanceImpl.java | 11 +++--------
.../java/org/apache/webbeans/portable/InstanceProducer.java | 2 +-
2 files changed, 4 insertions(+), 9 deletions(-)
diff --git a/webbeans-impl/src/main/java/org/apache/webbeans/inject/instance/InstanceImpl.java b/webbeans-impl/src/main/java/org/apache/webbeans/inject/instance/InstanceImpl.java
index 7fb53f4..1219a42 100644
--- a/webbeans-impl/src/main/java/org/apache/webbeans/inject/instance/InstanceImpl.java
+++ b/webbeans-impl/src/main/java/org/apache/webbeans/inject/instance/InstanceImpl.java
@@ -76,7 +76,6 @@ public class InstanceImpl<T> implements Instance<T>, Serializable
private WebBeansContext webBeansContext;
private Map<Object, CreationalContextImpl<?>> creationalContexts;
- private CreationalContextImpl<?> parentCreationalContext;
private boolean strictValidation;
@@ -86,15 +85,12 @@ public class InstanceImpl<T> implements Instance<T>, Serializable
* @param injectionClazz injection class type
* @param injectionPoint null or injection point
* @param webBeansContext
- * @param creationalContext will get used for creating @Dependent beans
* @param qualifiers qualifier annotations
*/
- public InstanceImpl(Type injectionClazz, InjectionPoint injectionPoint, WebBeansContext webBeansContext,
- CreationalContextImpl<?> creationalContext, Annotation... qualifiers)
+ public InstanceImpl(Type injectionClazz, InjectionPoint injectionPoint, WebBeansContext webBeansContext, Annotation... qualifiers)
{
this.injectionClazz = injectionClazz;
this.injectionPoint = injectionPoint;
- parentCreationalContext = creationalContext;
this.webBeansContext = webBeansContext;
strictValidation = webBeansContext.getOpenWebBeansConfiguration().strictDynamicValidation();
@@ -192,7 +188,7 @@ public class InstanceImpl<T> implements Instance<T>, Serializable
Annotation[] newQualifiersArray = qualifiers;
return new InstanceImpl<>(
injectionClazz, injectionPoint == null ? null : new InstanceInjectionPoint(injectionPoint, newQualifiersArray),
- webBeansContext, parentCreationalContext, newQualifiersArray);
+ webBeansContext, newQualifiersArray);
}
/**
@@ -220,7 +216,7 @@ public class InstanceImpl<T> implements Instance<T>, Serializable
? qualifiers
: qualifierAnnotations.toArray(new Annotation[qualifierAnnotations.size()]);
- return new InstanceImpl<>(sub, injectionPoint, webBeansContext, parentCreationalContext, effectiveQualifiers);
+ return new InstanceImpl<>(sub, injectionPoint, webBeansContext, effectiveQualifiers);
}
/**
@@ -329,7 +325,6 @@ public class InstanceImpl<T> implements Instance<T>, Serializable
injectionClazz = (Type)inputStream.readObject();
qualifierAnnotations = (Set<Annotation>)inputStream.readObject();
injectionPoint = (InjectionPoint) inputStream.readObject();
- parentCreationalContext = webBeansContext.getBeanManagerImpl().createCreationalContext(null); // TODO: check what we can do
}
public String toString()
diff --git a/webbeans-impl/src/main/java/org/apache/webbeans/portable/InstanceProducer.java b/webbeans-impl/src/main/java/org/apache/webbeans/portable/InstanceProducer.java
index 8775884..abd03b5 100644
--- a/webbeans-impl/src/main/java/org/apache/webbeans/portable/InstanceProducer.java
+++ b/webbeans-impl/src/main/java/org/apache/webbeans/portable/InstanceProducer.java
@@ -77,7 +77,7 @@ public class InstanceProducer<T> extends AbstractProducer<Instance<T>>
type = Object.class;
}
- return new InstanceImpl<>(type, injectionPoint, webBeansContext, creationalContextImpl, qualifiers.toArray(new Annotation[qualifiers.size()]));
+ return new InstanceImpl<>(type, injectionPoint, webBeansContext, qualifiers.toArray(new Annotation[qualifiers.size()]));
}
finally
{
[openwebbeans] 02/02: OWB-1297 adding unit test for InjectionPoint
for Instance
Posted by st...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
struberg pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/openwebbeans.git
commit 242a3412e4faf0d41bae5ea3b29a46b9cfe8e2b6
Author: Mark Struberg <st...@apache.org>
AuthorDate: Wed Sep 11 15:26:18 2019 +0200
OWB-1297 adding unit test for InjectionPoint for Instance<T>
---
.../test/instance/InstanceInjectionPointTest.java | 116 +++++++++++++++++++++
1 file changed, 116 insertions(+)
diff --git a/webbeans-impl/src/test/java/org/apache/webbeans/test/instance/InstanceInjectionPointTest.java b/webbeans-impl/src/test/java/org/apache/webbeans/test/instance/InstanceInjectionPointTest.java
new file mode 100644
index 0000000..308ef6a
--- /dev/null
+++ b/webbeans-impl/src/test/java/org/apache/webbeans/test/instance/InstanceInjectionPointTest.java
@@ -0,0 +1,116 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.webbeans.test.instance;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.context.Dependent;
+import javax.enterprise.context.RequestScoped;
+import javax.enterprise.inject.Any;
+import javax.enterprise.inject.Instance;
+import javax.enterprise.inject.Produces;
+import javax.enterprise.inject.spi.AnnotatedField;
+import javax.enterprise.inject.spi.InjectionPoint;
+import javax.inject.Inject;
+import javax.inject.Qualifier;
+
+import org.apache.webbeans.test.AbstractUnitTest;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Test that InjectionPoint works in case of {@code Instance<T>}.
+ */
+public class InstanceInjectionPointTest extends AbstractUnitTest {
+
+ @Test
+ public void testInstanceInjectionPointHandling() {
+ startContainer(SysInfoHolder.class, SysInfoProducer.class, System.class);
+
+ SysInfoProducer.injectionPoints.clear();
+
+ SysInfoHolder sysInfoHolder = getInstance(SysInfoHolder.class);
+ Assert.assertNotNull(sysInfoHolder);
+ List<SysInfo> sysInfos = sysInfoHolder.getSysInfos().stream().collect(Collectors.toList());
+ Assert.assertNotNull(sysInfos);
+ Assert.assertEquals(1, SysInfoProducer.injectionPoints.size());
+
+ InjectionPoint injectionPoint = SysInfoProducer.injectionPoints.get(0);
+ AnnotatedField af = (AnnotatedField) injectionPoint.getAnnotated();
+
+ Assert.assertEquals("sysInfos", af.getJavaMember().getName());
+ Assert.assertEquals(SysInfoHolder.class, af.getJavaMember().getDeclaringClass());
+ }
+
+
+ @RequestScoped
+ public static class SysInfoHolder {
+
+
+ private @Inject @Any Instance<SysInfo> sysInfos;
+
+ public Instance<SysInfo> getSysInfos() {
+ return sysInfos;
+ }
+ }
+
+ @ApplicationScoped
+ public static class SysInfoProducer {
+ public static List<InjectionPoint> injectionPoints = new ArrayList<>();
+
+ @Produces
+ @Dependent
+ public SysInfo createProductionSysInfo(InjectionPoint injectionPoint) {
+ SysInfo sysInfo = new SysInfo();
+ sysInfo.setName("production");
+
+ injectionPoints.add(injectionPoint);
+
+ return sysInfo;
+ }
+ }
+
+
+ @Qualifier
+ @Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER})
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface System {
+ String value();
+ }
+
+ @Dependent
+ public static class SysInfo {
+ private String name = "dummy";
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+ }
+
+
+}