From 7b387bffed5deb930a2d1f14c68fac11101d0480 Mon Sep 17 00:00:00 2001 From: Kyle Aure Date: Wed, 31 Jan 2024 14:41:48 -0600 Subject: [PATCH 1/2] Resolve TODOs --- .../Platform/anno/AnnotationFullTests.java | 19 ++- .../spec/Platform/anno/AnnotationServlet.java | 146 +++++++++++------- .../Platform/anno/AnnotationWebTests.java | 19 ++- .../spec/Platform/anno/application.xml | 7 +- .../tck/concurrent/spec/Platform/anno/web.xml | 7 +- .../dd/DeploymentDescriptorFullTests.java | 19 ++- .../dd/DeploymentDescriptorServlet.java | 129 +++++++++++----- .../dd/DeploymentDescriptorWebTests.java | 19 ++- .../spec/Platform/dd/application.xml | 5 +- .../tck/concurrent/spec/Platform/dd/web.xml | 5 +- 10 files changed, 258 insertions(+), 117 deletions(-) diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationFullTests.java b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationFullTests.java index 7496a3dd..132e1384 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationFullTests.java +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationFullTests.java @@ -77,8 +77,23 @@ protected String getServletPath() { return "AnnotationServlet"; } - @Assertion(id = "GIT:404", strategy = "Tests injection of concurrent resources defined in a annotation with qualifier(s).") - public void testAnnotationDefinesQualifiers() { + @Assertion(id = "GIT:404", strategy = "Tests injection of context service defined in an annotation with qualifier(s).") + public void testAnnoDefinedContextServiceQualifiers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed executor service defined in an annotation with qualifier(s).") + public void testAnnoDefinedManagedExecutorSvcQualifiers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed scheduled exectuor service defined in an annotation with qualifier(s).") + public void testAnnoDefinedManagedScheduledExecutorSvcQualifers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed thread factory defined in an annotation with qualifier(s).") + public void testAnnoDefinedManagedThreadFactoryQualifers() { runTest(baseURL, testname); } diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationServlet.java b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationServlet.java index e7e47606..d0dc05ce 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationServlet.java +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationServlet.java @@ -92,38 +92,6 @@ public class AnnotationServlet extends TestServlet { @Resource private UserTransaction tx; - - // Context Services - @Inject - private ContextService injectedDefContextSvc; - - @Inject - @CustomQualifier1 - private ContextService injectedContextD; - - // Managed Executor Services - @Inject - private ManagedExecutorService injectedDefMES; - - @Inject - @CustomQualifier2 - private ManagedExecutorService injectedMESD; - - // Managed Scheduled Executor Services - @Inject - private ManagedScheduledExecutorService injectedDefMSES; - - @Inject - @CustomQualifier1 - @CustomQualifier2 - private ManagedScheduledExecutorService injectedMSESD; - - // Managed Thread Factory - @Inject - private ManagedThreadFactory injectedDefMTF; - - @Resource(lookup = "java:app/concurrent/ThreadFactoryE") - private ManagedThreadFactory resourceMTFD; private Integer executeCallableWithContext(final ContextService svc, final int value) throws Exception { try { @@ -136,19 +104,26 @@ private Integer executeCallableWithContext(final ContextService svc, final int v IntContext.set(0); } } + + // Context Services + @Inject + private ContextService injectedDefContextSvc; - @SuppressWarnings("unused") - public void testAnnotationDefinesQualifiers() throws Throwable { + @Inject + @CustomQualifier1 + private ContextService injectedContextE; + + public void testAnnoDefinedContextServiceQualifiers() throws Throwable { assertAll("Context Service Tests", () -> assertNotNull(injectedDefContextSvc, "Default contextService was not registered with default qualifier."), - () -> assertNotNull(injectedContextD, + () -> assertNotNull(injectedContextE, "Annotation defined contextService was not registered with required qualifier."), () -> assertTrue(CDI.current().select(ContextService.class, InvalidQualifier3.Literal.get()).isUnsatisfied(), "A contextService was satisfied with a qualifier which was not defined in it's annotation") ); - // Verify injected and lookup default context service are the same + // Verify injected and looked up default context service are the same ContextService lookupDefContextSvc = InitialContext.doLookup("java:comp/DefaultContextService"); Integer expected1 = executeCallableWithContext(lookupDefContextSvc, 95); @@ -156,53 +131,118 @@ public void testAnnotationDefinesQualifiers() throws Throwable { assertEquals(expected1, actual1, "Default Context Service behavior differed between injection and lookup"); - // Verify injected and lookup annotation defined context service are the same - ContextService lookupContextD = InitialContext.doLookup("java:app/concurrent/ContextD"); + // Verify injected and looked up annotation defined context service are the same + ContextService lookupContextE = InitialContext.doLookup("java:app/concurrent/ContextE"); - assertEquals(Integer.valueOf(0), executeCallableWithContext(lookupContextD, 65), + assertEquals(Integer.valueOf(0), executeCallableWithContext(lookupContextE, 65), "Annotation defined Context Service that was looked up did not clear the IntContext as configured."); - assertEquals(Integer.valueOf(0), executeCallableWithContext(injectedContextD, 85), + assertEquals(Integer.valueOf(0), executeCallableWithContext(injectedContextE, 85), "Annotation defined Context Service that was injected based on a qualifier did not clear the IntContext as configured."); + } + + // Managed Executor Services + @Inject + private ManagedExecutorService injectedDefMES; - ManagedExecutorService lookupDefMES = InitialContext.doLookup("java:comp/DefaultManagedExecutorService"); - ManagedExecutorService lookupMESD = InitialContext.doLookup("java:app/concurrent/ExecutorE"); - + @Inject + @CustomQualifier2 + private ManagedExecutorService injectedMESE; + + public void testAnnoDefinedManagedExecutorSvcQualifiers() throws Throwable { assertAll("Managed Executor Service Tests", () -> assertNotNull(injectedDefMES, "Default managedExecutorService was not registered with default qualifier."), - () -> assertNotNull(injectedMESD, + () -> assertNotNull(injectedMESE, "Annotation defined managedExecutorService was not registered with required qualifiers."), () -> assertTrue(CDI.current().select(ManagedExecutorService.class, CustomQualifier2.Literal.get(), InvalidQualifier3.Literal.get()).isUnsatisfied(), "A managedExecutorService was satisfied with both a required and non-required qualifier.") ); - //TODO verify injected vs lookup services behave the same + // Verify injected and looked up default ManagedExecutorService behave the same + ManagedExecutorService lookupDefMES = InitialContext.doLookup("java:comp/DefaultManagedExecutorService"); - ManagedScheduledExecutorService lookupDefMSES = InitialContext.doLookup("java:comp/DefaultManagedScheduledExecutorService"); - ManagedScheduledExecutorService lookupMSESD = InitialContext.doLookup("java:app/concurrent/ScheduledExecutorE"); + ContextService lookupDefContextSvc = lookupDefMES.getContextService(); + ContextService extractedDefContextSvc = injectedDefMES.getContextService(); + + Integer expected1 = executeCallableWithContext(lookupDefContextSvc, 95); + Integer actual1 = executeCallableWithContext(extractedDefContextSvc, 95); + + assertEquals(expected1, actual1, "Default ManagedExecutorService behavior via context service differed between injection and lookup"); + // Verify injected and looked up annotation defined ManagedExecutorService behave the same + ManagedExecutorService lookupMESE = InitialContext.doLookup("java:app/concurrent/ExecutorE"); + + ContextService lookupContextE = lookupMESE.getContextService(); + ContextService extractedContextE = injectedMESE.getContextService(); + + assertEquals(Integer.valueOf(0), executeCallableWithContext(lookupContextE, 65), + "Annotation defined and looked up ManagedExecutorService was configured with a context service that did not clear the IntContext as configured."); + assertEquals(Integer.valueOf(0), executeCallableWithContext(extractedContextE, 85), + "Annotation defined and injected ManagedExecutorService was configured with a context service that did not clear the IntContext as configured."); + } + + // Managed Scheduled Executor Services + @Inject + private ManagedScheduledExecutorService injectedDefMSES; + + @Inject + @CustomQualifier1 + @CustomQualifier2 + private ManagedScheduledExecutorService injectedMSESE; + + public void testAnnoDefinedManagedScheduledExecutorSvcQualifers() throws Throwable { assertAll("Managed Scheduled Executor Service Tests", () -> assertNotNull(injectedDefMSES, "Default managedScheduledExecutorService was not registered with default qualifier."), - () -> assertNotNull(injectedMSESD, + () -> assertNotNull(injectedMSESE, "Annotation defined managedScheduledExecutorService was not registered with required qualifiers."), () -> assertTrue(CDI.current().select(ManagedScheduledExecutorService.class, CustomQualifier1.Literal.get()).isResolvable(), "A managedScheduledExecutorService was not satisfied with one of two configured qualifiers.") ); - //TODO verify injected vs lookup services behave the same + // Verify injected and looked up default ManagedScheduledExecutorService behave the same + ManagedScheduledExecutorService lookupDefMSES = InitialContext.doLookup("java:comp/DefaultManagedScheduledExecutorService"); - ManagedThreadFactory lookupDefMTF = InitialContext.doLookup("java:comp/DefaultManagedThreadFactory"); - ManagedThreadFactory lookupMTFD = InitialContext.doLookup("java:app/concurrent/ThreadFactoryE"); + ContextService lookupDefContextSvc = lookupDefMSES.getContextService(); + ContextService extractedDefContextSvc = injectedDefMSES.getContextService(); + + Integer expected1 = executeCallableWithContext(lookupDefContextSvc, 95); + Integer actual1 = executeCallableWithContext(extractedDefContextSvc, 95); + + assertEquals(expected1, actual1, "Default ManagedScheduledExecutorService behavior via context service differed between injection and lookup"); + // Verify injected and looked up annotation defined ManagedExecutorService behave the same + ManagedScheduledExecutorService lookupMSESE = InitialContext.doLookup("java:app/concurrent/ScheduledExecutorE"); + + ContextService lookupContextE = lookupMSESE.getContextService(); + ContextService extractedContextE = injectedMSESE.getContextService(); + + assertEquals(Integer.valueOf(0), executeCallableWithContext(lookupContextE, 65), + "Annotation defined and looked up ManagedScheduledExecutorService was configured with a context service that did not clear the IntContext as configured."); + assertEquals(Integer.valueOf(0), executeCallableWithContext(extractedContextE, 85), + "Annotation defined and injected ManagedScheduledExecutorService was configured with a context service that did not clear the IntContext as configured."); + } + + // Managed Thread Factory + @Inject + private ManagedThreadFactory injectedDefMTF; + + @Resource(lookup = "java:app/concurrent/ThreadFactoryE") + private ManagedThreadFactory resourceMTFE; + + public void testAnnoDefinedManagedThreadFactoryQualifers() throws Throwable { + + ManagedThreadFactory lookupDefMTF = InitialContext.doLookup("java:comp/DefaultManagedThreadFactory"); + ManagedThreadFactory lookupMTFE = InitialContext.doLookup("java:app/concurrent/ThreadFactoryD"); + assertAll("Thread Factory Tests", () -> assertNotNull(injectedDefMTF, "Default managedThreadFactory was not registered with default qualifier."), () -> assertEquals(lookupDefMTF.newThread(NOOP_RUNNABLE).getPriority(), injectedDefMTF.newThread(NOOP_RUNNABLE).getPriority(), "Default managedThreadFactory from injection and lookup did not have the same priority."), - () -> assertNotNull(resourceMTFD, + () -> assertNotNull(resourceMTFE, "Annotation defined managedThreadFactory with no qualifiers could not be found via @Resource."), - () -> assertEquals(lookupMTFD.newThread(NOOP_RUNNABLE).getPriority(), resourceMTFD.newThread(NOOP_RUNNABLE).getPriority(), + () -> assertEquals(lookupMTFE.newThread(NOOP_RUNNABLE).getPriority(), resourceMTFE.newThread(NOOP_RUNNABLE).getPriority(), "The managedThreadFactory from resource injection and lookup did not have the same priority."), () -> assertTrue(CDI.current().select(ManagedThreadFactory.class, InvalidQualifier3.Literal.get()).isUnsatisfied(), "A managedThreadFactory was satisfied with a required qualifier that should have been overriden by the deployment descriptor.") diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationWebTests.java b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationWebTests.java index 4ccc0247..9074ea22 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationWebTests.java +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/AnnotationWebTests.java @@ -63,8 +63,23 @@ protected String getServletPath() { return "AnnotationServlet"; } - @Assertion(id = "GIT:404", strategy = "Tests injection of concurrent resources defined in a annotation with qualifier(s).") - public void testAnnotationDefinesQualifiers() { + @Assertion(id = "GIT:404", strategy = "Tests injection of context service defined in an annotation with qualifier(s).") + public void testAnnoDefinedContextServiceQualifiers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed executor service defined in an annotation with qualifier(s).") + public void testAnnoDefinedManagedExecutorSvcQualifiers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed scheduled exectuor service defined in an annotation with qualifier(s).") + public void testAnnoDefinedManagedScheduledExecutorSvcQualifers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed thread factory defined in an annotation with qualifier(s).") + public void testAnnoDefinedManagedThreadFactoryQualifers() { runTest(baseURL, testname); } diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/application.xml b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/application.xml index 36d20579..00db76a4 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/application.xml +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/application.xml @@ -16,11 +16,10 @@ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 --> - - + xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/application_11.xsd"> @@ -34,7 +33,7 @@ - java:app/concurrent/ThreadFactoryD + java:app/concurrent/ThreadFactoryE diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/web.xml b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/web.xml index accac35c..6a9b20ea 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/web.xml +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/anno/web.xml @@ -16,15 +16,14 @@ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 --> - + xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_1.xsd"> - java:app/concurrent/ThreadFactoryD + java:app/concurrent/ThreadFactoryE diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorFullTests.java b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorFullTests.java index c1c37ed1..a69d1119 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorFullTests.java +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorFullTests.java @@ -77,8 +77,23 @@ protected String getServletPath() { return "DeploymentDescriptorServlet"; } - @Assertion(id = "GIT:404", strategy = "Tests injection of concurrent resources defined in a deployment descriptor with qualifier(s).") - public void testDeploymentDescriptorDefinesQualifiers() { + @Assertion(id = "GIT:404", strategy = "Tests injection of context service defined in a deployment descriptor with qualifier(s).") + public void testDeploymentDescriptorDefinedContextServiceQualifiers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed executor service defined in a deployment descriptor with qualifier(s).") + public void testDeploymentDescriptorDefinedManagedExecutorSvcQualifiers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed scheduled exectuor service defined in a deployment descriptor with qualifier(s).") + public void testDeploymentDescriptorDefinedManagedScheduledExecutorSvcQualifers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed thread factory defined in a deployment descriptor with qualifier(s).") + public void testDeploymentDescriptorDefinedManagedThreadFactoryQualifers() { runTest(baseURL, testname); } diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorServlet.java b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorServlet.java index 5d9f32c0..613fe75e 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorServlet.java +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorServlet.java @@ -61,39 +61,8 @@ public class DeploymentDescriptorServlet extends TestServlet { @Resource private UserTransaction tx; - - // Context Services - @Inject - private ContextService injectedDefContextSvc; - - @Inject - @CustomQualifier1 - private ContextService injectedContextD; - - // Managed Executor Services - @Inject - private ManagedExecutorService injectedDefMES; - - @Inject - @CustomQualifier2 - private ManagedExecutorService injectedMESD; - - // Managed Scheduled Executor Services - @Inject - private ManagedScheduledExecutorService injectedDefMSES; - - @Inject - @CustomQualifier1 - @CustomQualifier2 - private ManagedScheduledExecutorService injectedMSESD; - // Managed Thread Factory - @Inject - private ManagedThreadFactory injectedDefMTF; - @Resource(lookup = "java:app/concurrent/ThreadFactoryD") - private ManagedThreadFactory resourceMTFD; - private Integer executeCallableWithContext(final ContextService svc, final int value) throws Exception { try { IntContext.set(value); @@ -105,10 +74,16 @@ private Integer executeCallableWithContext(final ContextService svc, final int v IntContext.set(0); } } + + // Context Services + @Inject + private ContextService injectedDefContextSvc; - @SuppressWarnings("unused") - public void testDeploymentDescriptorDefinesQualifiers() throws Throwable { - + @Inject + @CustomQualifier1 + private ContextService injectedContextD; + + public void testDeploymentDescriptorDefinedContextServiceQualifiers() throws Throwable { assertAll("Context Service Tests", () -> assertNotNull(injectedDefContextSvc, "Default contextService was not registered with default qualifier."), @@ -134,9 +109,17 @@ public void testDeploymentDescriptorDefinesQualifiers() throws Throwable { assertEquals(Integer.valueOf(0), executeCallableWithContext(injectedContextD, 85), "Deployment descriptor defined Context Service that was injected based on a qualifier did not clear the IntContext as configured."); - ManagedExecutorService lookupDefMES = InitialContext.doLookup("java:comp/DefaultManagedExecutorService"); - ManagedExecutorService lookupMESD = InitialContext.doLookup("java:app/concurrent/ExecutorD"); - + } + + // Managed Executor Services + @Inject + private ManagedExecutorService injectedDefMES; + + @Inject + @CustomQualifier2 + private ManagedExecutorService injectedMESD; + + public void testDeploymentDescriptorDefinedManagedExecutorSvcQualifiers() throws Throwable { assertAll("Managed Executor Service Tests", () -> assertNotNull(injectedDefMES, "Default managedExecutorService was not registered with default qualifier."), @@ -146,11 +129,40 @@ public void testDeploymentDescriptorDefinesQualifiers() throws Throwable { "A managedExecutorService was satisfied with both a required and non-required qualifier.") ); - //TODO verify injected vs lookup services behave the same - ManagedScheduledExecutorService lookupDefMSES = InitialContext.doLookup("java:comp/DefaultManagedScheduledExecutorService"); - ManagedScheduledExecutorService lookupMSESD = InitialContext.doLookup("java:app/concurrent/ScheduledExecutorD"); + // Verify injected and looked up default ManagedExecutorService behave the same + ManagedExecutorService lookupDefMES = InitialContext.doLookup("java:comp/DefaultManagedExecutorService"); + + ContextService lookupDefContextSvc = lookupDefMES.getContextService(); + ContextService extractedDefContextSvc = injectedDefMES.getContextService(); + + Integer expected1 = executeCallableWithContext(lookupDefContextSvc, 95); + Integer actual1 = executeCallableWithContext(extractedDefContextSvc, 95); + + assertEquals(expected1, actual1, "Default ManagedExecutorService behavior via context service differed between injection and lookup"); + // Verify injected and lookup deployment descriptor defined ManagedExecutorService behave the same + ManagedExecutorService lookupMESD = InitialContext.doLookup("java:app/concurrent/ExecutorD"); + + ContextService lookupContextE = lookupMESD.getContextService(); + ContextService extractedContextE = injectedMESD.getContextService(); + + assertEquals(Integer.valueOf(0), executeCallableWithContext(lookupContextE, 65), + "Deployment descriptor defined and looked up ManagedExecutorService was configured with a context service that did not clear the IntContext as configured."); + assertEquals(Integer.valueOf(0), executeCallableWithContext(extractedContextE, 85), + "Deployment descriptor defined and injected ManagedExecutorService was configured with a context service that did not clear the IntContext as configured."); + } + + // Managed Scheduled Executor Services + @Inject + private ManagedScheduledExecutorService injectedDefMSES; + + @Inject + @CustomQualifier1 + @CustomQualifier2 + private ManagedScheduledExecutorService injectedMSESD; + + public void testDeploymentDescriptorDefinedManagedScheduledExecutorSvcQualifers() throws Throwable { assertAll("Managed Scheduled Executor Service Tests", () -> assertNotNull(injectedDefMSES, "Default managedScheduledExecutorService was not registered with default qualifier."), @@ -160,11 +172,44 @@ public void testDeploymentDescriptorDefinesQualifiers() throws Throwable { "A managedScheduledExecutorService was not satisfied with one of two configured qualifiers.") ); - //TODO verify injected vs lookup services behave the same + // Verify injected and looked up default ManagedScheduledExecutorService behave the same + ManagedScheduledExecutorService lookupDefMSES = InitialContext.doLookup("java:comp/DefaultManagedScheduledExecutorService"); + + ContextService lookupDefContextSvc = lookupDefMSES.getContextService(); + ContextService extractedDefContextSvc = injectedDefMSES.getContextService(); + + Integer expected1 = executeCallableWithContext(lookupDefContextSvc, 95); + Integer actual1 = executeCallableWithContext(extractedDefContextSvc, 95); + + assertEquals(expected1, actual1, "Default ManagedScheduledExecutorService behavior via context service differed between injection and lookup"); + + // Verify injected and looked up annotation defined ManagedExecutorService behave the same + ManagedScheduledExecutorService lookupMSESD = InitialContext.doLookup("java:app/concurrent/ScheduledExecutorD"); + + ContextService lookupContextE = lookupMSESD.getContextService(); + ContextService extractedContextE = injectedMSESD.getContextService(); + + assertEquals(Integer.valueOf(0), executeCallableWithContext(lookupContextE, 65), + "Deployment descriptor defined and looked up ManagedScheduledExecutorService" + + " was configured with a context service that did not clear the IntContext as configured."); + assertEquals(Integer.valueOf(0), executeCallableWithContext(extractedContextE, 85), + "Deployment descriptor defined and injected ManagedScheduledExecutorService" + + " was configured with a context service that did not clear the IntContext as configured."); + + } + + // Managed Thread Factory + @Inject + private ManagedThreadFactory injectedDefMTF; + + @Resource(lookup = "java:app/concurrent/ThreadFactoryD") + private ManagedThreadFactory resourceMTFD; + + public void testDeploymentDescriptorDefinedManagedThreadFactoryQualifers() throws Throwable { ManagedThreadFactory lookupDefMTF = InitialContext.doLookup("java:comp/DefaultManagedThreadFactory"); ManagedThreadFactory lookupMTFD = InitialContext.doLookup("java:app/concurrent/ThreadFactoryD"); - + assertAll("Thread Factory Tests", () -> assertNotNull(injectedDefMTF, "Default managedThreadFactory was not registered with default qualifier."), diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorWebTests.java b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorWebTests.java index 38c77628..c45129da 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorWebTests.java +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorWebTests.java @@ -63,8 +63,23 @@ protected String getServletPath() { return "DeploymentDescriptorServlet"; } - @Assertion(id = "GIT:404", strategy = "Tests injection of concurrent resources defined in a deployment descriptor with qualifier(s).") - public void testDeploymentDescriptorDefinesQualifiers() { + @Assertion(id = "GIT:404", strategy = "Tests injection of context service defined in a deployment descriptor with qualifier(s).") + public void testDeploymentDescriptorDefinedContextServiceQualifiers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed executor service defined in a deployment descriptor with qualifier(s).") + public void testDeploymentDescriptorDefinedManagedExecutorSvcQualifiers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed scheduled exectuor service defined in a deployment descriptor with qualifier(s).") + public void testDeploymentDescriptorDefinedManagedScheduledExecutorSvcQualifers() { + runTest(baseURL, testname); + } + + @Assertion(id = "GIT:404", strategy = "Tests injection of managed thread factory defined in a deployment descriptor with qualifier(s).") + public void testDeploymentDescriptorDefinedManagedThreadFactoryQualifers() { runTest(baseURL, testname); } diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/application.xml b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/application.xml index 478d0e07..65708cbb 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/application.xml +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/application.xml @@ -16,11 +16,10 @@ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 --> - - + xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/application_11.xsd"> diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/web.xml b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/web.xml index 86f59bd7..500d4442 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/web.xml +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/web.xml @@ -16,12 +16,11 @@ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 --> - + xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_1.xsd"> java:app/concurrent/ContextD From 2289d05275c7ac8b94861e9e729496d3bc1820cf Mon Sep 17 00:00:00 2001 From: Kyle Aure Date: Wed, 31 Jan 2024 15:50:45 -0600 Subject: [PATCH 2/2] Add test for app defined default producer --- .../dd/DeploymentDescriptorFullTests.java | 2 +- .../Platform/dd/DeploymentDescriptorServlet.java | 10 ++++++---- .../dd/ManagedThreadFactoryProducer.java | 16 ++++++++++++++++ .../concurrent/spec/Platform/dd/application.xml | 6 ++++++ .../tck/concurrent/spec/Platform/dd/web.xml | 6 ++++++ 5 files changed, 35 insertions(+), 5 deletions(-) create mode 100644 tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/ManagedThreadFactoryProducer.java diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorFullTests.java b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorFullTests.java index a69d1119..408ff668 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorFullTests.java +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorFullTests.java @@ -50,7 +50,7 @@ public class DeploymentDescriptorFullTests extends TestClient { public static EnterpriseArchive createDeployment() { WebArchive war = ShrinkWrap.create(WebArchive.class, "DeploymentDescriptorTests_web.war") - .addClasses(DeploymentDescriptorServlet.class); + .addClasses(DeploymentDescriptorServlet.class, ManagedThreadFactoryProducer.class); JavaArchive jar = ShrinkWrap.create(JavaArchive.class, "DeploymentDescriptorTests_ejb.jar") .addClasses(DeploymentDescriptorTestBean.class, DeploymentDescriptorTestBeanInterface.class) diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorServlet.java b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorServlet.java index 613fe75e..5a8c22e0 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorServlet.java +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/DeploymentDescriptorServlet.java @@ -212,15 +212,17 @@ public void testDeploymentDescriptorDefinedManagedThreadFactoryQualifers() throw assertAll("Thread Factory Tests", () -> assertNotNull(injectedDefMTF, - "Default managedThreadFactory was not registered with default qualifier."), - () -> assertEquals(lookupDefMTF.newThread(NOOP_RUNNABLE).getPriority(), injectedDefMTF.newThread(NOOP_RUNNABLE).getPriority(), - "Default managedThreadFactory from injection and lookup did not have the same priority."), + "A managedThreadFactory was not registered with the default qualifier when the application included a producer."), + () -> assertEquals(5, lookupDefMTF.newThread(NOOP_RUNNABLE).getPriority(), + "Default managedThreadFactory from lookup did not have the default priority."), + () -> assertEquals(7, injectedDefMTF.newThread(NOOP_RUNNABLE).getPriority(), + "Default managedThreadFactory from injection did not have the expected priority."), () -> assertNotNull(resourceMTFD, "Deployment Descriptor defined managedThreadFactory with no qualifiers could not be found via @Resource."), () -> assertEquals(lookupMTFD.newThread(NOOP_RUNNABLE).getPriority(), resourceMTFD.newThread(NOOP_RUNNABLE).getPriority(), "The managedThreadFactory from resource injection and lookup did not have the same priority."), () -> assertTrue(CDI.current().select(ManagedThreadFactory.class, CustomQualifier1.Literal.get()).isUnsatisfied(), - "A managedThreadFactory was satisfied with a required qualifier that should have been overriden by the deployment descriptor.") + "A managedThreadFactory was satisfied with a required qualifier that was not configured on the deployment descriptor.") ); } diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/ManagedThreadFactoryProducer.java b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/ManagedThreadFactoryProducer.java new file mode 100644 index 00000000..39e190c8 --- /dev/null +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/ManagedThreadFactoryProducer.java @@ -0,0 +1,16 @@ +package ee.jakarta.tck.concurrent.spec.Platform.dd; + +import javax.naming.InitialContext; + +import jakarta.enterprise.concurrent.ManagedThreadFactory; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.enterprise.inject.Produces; + +@ApplicationScoped +public class ManagedThreadFactoryProducer { + + @Produces + public ManagedThreadFactory getDefaultManagedThreadFactory() throws Exception { + return InitialContext.doLookup("java:app/concurrent/ThreadFactoryDefault"); + } +} diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/application.xml b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/application.xml index 65708cbb..6924f662 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/application.xml +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/application.xml @@ -63,5 +63,11 @@ 6 + + + java:app/concurrent/ThreadFactoryDefault + java:comp/DefaultContextService + 7 + diff --git a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/web.xml b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/web.xml index 500d4442..41db6ae6 100644 --- a/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/web.xml +++ b/tck/src/main/java/ee/jakarta/tck/concurrent/spec/Platform/dd/web.xml @@ -53,5 +53,11 @@ 6 + + + java:app/concurrent/ThreadFactoryDefault + java:comp/DefaultContextService + 7 + \ No newline at end of file