Repository: eclipse/microprofile-lra (java)

Issue:
TCK: LRA placement on interface and super classes
We need some TCK tests to prove implemenation picks up the @LRA on a interface and super class.

Proposal: Duplicate `TckLRATypeTests` but once for @LRA on an interface and once for @LRA on superclass.

Pull request:
issue214 Add TCK for LRA placement on interface and super classes
resolves #214 

Patch:
diff --git a/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckInterface.java b/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckInterface.java
new file mode 100644
index 0000000..a8a12d4
--- /dev/null
+++ b/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckInterface.java
@@ -0,0 +1,108 @@
+/*
+ *******************************************************************************
+ * Copyright (c) 2020 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * Licensed 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.eclipse.microprofile.lra.tck.participant.api;
+
+import org.eclipse.microprofile.lra.annotation.ws.rs.LRA;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Response;
+import java.net.URI;
+
+import static org.eclipse.microprofile.lra.annotation.ws.rs.LRA.LRA_HTTP_CONTEXT_HEADER;
+
+public interface LRATypeTckInterface {
+
+    String REQUIRED_PATH = "/required";
+    String REQUIRES_NEW_PATH = "/requires-new";
+    String SUPPORTS_PATH = "/supports";
+    String NOT_SUPPORTED_PATH = "/not-supported";
+    String MANDATORY_PATH = "/mandatory";
+    String NEVER_PATH = "/never";
+
+    String REQUIRED_WITH_END_FALSE_PATH = "/end-required";
+    String REQUIRES_NEW_WITH_END_FALSE_PATH = "/end-requires-new";
+    String SUPPORTS_WITH_END_FALSE_PATH = "/end-supports";
+    String NOT_SUPPORTED_WITH_END_FALSE_PATH = "/end-not-supported";
+    String MANDATORY_WITH_END_FALSE_PATH = "/end-mandatory";
+    String NEVER_WITH_END_FALSE_PATH = "/end-never";
+
+    @GET
+    @Path(REQUIRED_PATH)
+    @LRA(value = LRA.Type.REQUIRED)
+    Response requiredLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(REQUIRES_NEW_PATH)
+    @LRA(value = LRA.Type.REQUIRES_NEW)
+    Response requiresNewLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(MANDATORY_PATH)
+    @LRA(value = LRA.Type.MANDATORY)
+    Response mandatoryLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(SUPPORTS_PATH)
+    @LRA(value = LRA.Type.SUPPORTS)
+    Response supportsLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(NOT_SUPPORTED_PATH)
+    @LRA(value = LRA.Type.NOT_SUPPORTED)
+    Response notSupportedLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(NEVER_PATH)
+    @LRA(value = LRA.Type.NEVER)
+    Response neverLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(REQUIRED_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.REQUIRED, end = false)
+    Response requiredEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(REQUIRES_NEW_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.REQUIRES_NEW, end = false)
+    Response requiresNewEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(MANDATORY_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.MANDATORY, end = false)
+    Response mandatoryEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(SUPPORTS_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.SUPPORTS, end = false)
+    Response supportsEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(NOT_SUPPORTED_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.NOT_SUPPORTED, end = false)
+    Response notSupportedEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(NEVER_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.NEVER, end = false)
+    Response neverEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+}
diff --git a/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckInterfaceResource.java b/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckInterfaceResource.java
new file mode 100644
index 0000000..6a03de2
--- /dev/null
+++ b/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckInterfaceResource.java
@@ -0,0 +1,78 @@
+/*
+ *******************************************************************************
+ * Copyright (c) 2020 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * Licensed 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.eclipse.microprofile.lra.tck.participant.api;
+
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Response;
+import java.net.URI;
+
+@Path(LRATypeTckInterfaceResource.TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH)
+public class LRATypeTckInterfaceResource implements LRATypeTckInterface {
+
+    public static final String TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH = "lra-type-tck-interface-resource";
+
+    public Response requiredLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response requiresNewLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response mandatoryLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response supportsLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response notSupportedLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response neverLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response requiredEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response requiresNewEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response mandatoryEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response supportsEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response notSupportedEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response neverEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+}
diff --git a/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckResource.java b/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckResource.java
index 1da00de..688aa7f 100644
--- a/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckResource.java
+++ b/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckResource.java
@@ -34,6 +34,7 @@ import static org.eclipse.microprofile.lra.annotation.ws.rs.LRA.LRA_HTTP_CONTEXT
 @ApplicationScoped
 @Path(LRATypeTckResource.TCK_LRA_TYPE_RESOURCE_PATH)
 public class LRATypeTckResource {
+
     public static final String TCK_LRA_TYPE_RESOURCE_PATH = "lra-type-tck-resource";
 
     public static final String REQUIRED_PATH = "/required";
@@ -51,36 +52,42 @@ public class LRATypeTckResource {
     public static final String NEVER_WITH_END_FALSE_PATH = "/end-never";
 
     // resource methods for each LRA.Type attribute
+
     @GET
     @Path(REQUIRED_PATH)
     @LRA(value = LRA.Type.REQUIRED)
     public Response requiredLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
+
     @GET
     @Path(REQUIRES_NEW_PATH)
     @LRA(value = LRA.Type.REQUIRES_NEW)
     public Response requiresNewLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
+
     @GET
     @Path(MANDATORY_PATH)
     @LRA(value = LRA.Type.MANDATORY)
     public Response mandatoryLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
+
     @GET
     @Path(SUPPORTS_PATH)
     @LRA(value = LRA.Type.SUPPORTS)
     public Response supportsLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
+
     @GET
     @Path(NOT_SUPPORTED_PATH)
     @LRA(value = LRA.Type.NOT_SUPPORTED)
     public Response notSupportedLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
+
     @GET
     @Path(NEVER_PATH)
     @LRA(value = LRA.Type.NEVER)
@@ -89,40 +96,46 @@ public class LRATypeTckResource {
     }
 
     // similar set of resources methods but with the LRA.end attribute set to false
+
     @GET
     @Path(REQUIRED_WITH_END_FALSE_PATH)
     @LRA(value = LRA.Type.REQUIRED, end = false)
     public Response requiredEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
+
     @GET
     @Path(REQUIRES_NEW_WITH_END_FALSE_PATH)
     @LRA(value = LRA.Type.REQUIRES_NEW, end = false)
     public Response requiresNewEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
+
     @GET
     @Path(MANDATORY_WITH_END_FALSE_PATH)
     @LRA(value = LRA.Type.MANDATORY, end = false)
     public Response mandatoryEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
+
     @GET
     @Path(SUPPORTS_WITH_END_FALSE_PATH)
     @LRA(value = LRA.Type.SUPPORTS, end = false)
     public Response supportsEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
+
     @GET
     @Path(NOT_SUPPORTED_WITH_END_FALSE_PATH)
     @LRA(value = LRA.Type.NOT_SUPPORTED, end = false)
     public Response notSupportedEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
+
     @GET
     @Path(NEVER_WITH_END_FALSE_PATH)
     @LRA(value = LRA.Type.NEVER, end = false)
     public Response neverEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId) {
         return Response.ok(lraId).build();
     }
-}
\ No newline at end of file
+}
diff --git a/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckSuperclass.java b/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckSuperclass.java
new file mode 100644
index 0000000..28be8ed
--- /dev/null
+++ b/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckSuperclass.java
@@ -0,0 +1,108 @@
+/*
+ *******************************************************************************
+ * Copyright (c) 2019 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * Licensed 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.eclipse.microprofile.lra.tck.participant.api;
+
+import org.eclipse.microprofile.lra.annotation.ws.rs.LRA;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Response;
+import java.net.URI;
+
+import static org.eclipse.microprofile.lra.annotation.ws.rs.LRA.LRA_HTTP_CONTEXT_HEADER;
+
+public abstract class LRATypeTckSuperclass {
+
+    public static final String REQUIRED_PATH = "/required";
+    public static final String REQUIRES_NEW_PATH = "/requires-new";
+    public static final String SUPPORTS_PATH = "/supports";
+    public static final String NOT_SUPPORTED_PATH = "/not-supported";
+    public static final String MANDATORY_PATH = "/mandatory";
+    public static final String NEVER_PATH = "/never";
+
+    public static final String REQUIRED_WITH_END_FALSE_PATH = "/end-required";
+    public static final String REQUIRES_NEW_WITH_END_FALSE_PATH = "/end-requires-new";
+    public static final String SUPPORTS_WITH_END_FALSE_PATH = "/end-supports";
+    public static final String NOT_SUPPORTED_WITH_END_FALSE_PATH = "/end-not-supported";
+    public static final String MANDATORY_WITH_END_FALSE_PATH = "/end-mandatory";
+    public static final String NEVER_WITH_END_FALSE_PATH = "/end-never";
+
+    @GET
+    @Path(REQUIRED_PATH)
+    @LRA(value = LRA.Type.REQUIRED)
+    public abstract Response requiredLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(REQUIRES_NEW_PATH)
+    @LRA(value = LRA.Type.REQUIRES_NEW)
+    public abstract Response requiresNewLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(MANDATORY_PATH)
+    @LRA(value = LRA.Type.MANDATORY)
+    public abstract Response mandatoryLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(SUPPORTS_PATH)
+    @LRA(value = LRA.Type.SUPPORTS)
+    public abstract Response supportsLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(NOT_SUPPORTED_PATH)
+    @LRA(value = LRA.Type.NOT_SUPPORTED)
+    public abstract Response notSupportedLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(NEVER_PATH)
+    @LRA(value = LRA.Type.NEVER)
+    public abstract Response neverLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(REQUIRED_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.REQUIRED, end = false)
+    public abstract Response requiredEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(REQUIRES_NEW_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.REQUIRES_NEW, end = false)
+    public abstract Response requiresNewEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(MANDATORY_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.MANDATORY, end = false)
+    public abstract Response mandatoryEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(SUPPORTS_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.SUPPORTS, end = false)
+    public abstract Response supportsEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(NOT_SUPPORTED_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.NOT_SUPPORTED, end = false)
+    public abstract Response notSupportedEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+    @GET
+    @Path(NEVER_WITH_END_FALSE_PATH)
+    @LRA(value = LRA.Type.NEVER, end = false)
+    public abstract Response neverEndLRA(@HeaderParam(LRA_HTTP_CONTEXT_HEADER) URI lraId);
+
+}
diff --git a/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckSuperclassResource.java b/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckSuperclassResource.java
new file mode 100644
index 0000000..221380a
--- /dev/null
+++ b/tck/src/main/java/org/eclipse/microprofile/lra/tck/participant/api/LRATypeTckSuperclassResource.java
@@ -0,0 +1,78 @@
+/*
+ *******************************************************************************
+ * Copyright (c) 2020 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * Licensed 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.eclipse.microprofile.lra.tck.participant.api;
+
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Response;
+import java.net.URI;
+
+@Path(LRATypeTckSuperclassResource.TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH)
+public class LRATypeTckSuperclassResource extends LRATypeTckSuperclass {
+
+    public static final String TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH = "lra-type-tck-superclass-resource";
+
+    public Response requiredLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response requiresNewLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response mandatoryLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response supportsLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response notSupportedLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response neverLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response requiredEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response requiresNewEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response mandatoryEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response supportsEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response notSupportedEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+
+    public Response neverEndLRA(URI lraId) {
+        return Response.ok(lraId).build();
+    }
+}


Test patch:
diff --git a/tck/src/main/java/org/eclipse/microprofile/lra/tck/TckLRATypeTests.java b/tck/src/main/java/org/eclipse/microprofile/lra/tck/TckLRATypeTests.java
index 1ab8db9..68027ad 100644
--- a/tck/src/main/java/org/eclipse/microprofile/lra/tck/TckLRATypeTests.java
+++ b/tck/src/main/java/org/eclipse/microprofile/lra/tck/TckLRATypeTests.java
@@ -20,6 +20,9 @@
 package org.eclipse.microprofile.lra.tck;
 
 import org.eclipse.microprofile.lra.annotation.ws.rs.LRA;
+import org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckInterface;
+import org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource;
+import org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckSuperclass;
 import org.jboss.arquillian.container.test.api.Deployment;
 import org.jboss.arquillian.junit.Arquillian;
 import org.jboss.shrinkwrap.api.spec.WebArchive;
@@ -33,19 +36,9 @@ import java.net.URI;
 import java.time.temporal.ChronoUnit;
 import java.util.logging.Logger;
 
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.MANDATORY_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.MANDATORY_WITH_END_FALSE_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.NEVER_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.NEVER_WITH_END_FALSE_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.NOT_SUPPORTED_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.NOT_SUPPORTED_WITH_END_FALSE_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.REQUIRED_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.REQUIRED_WITH_END_FALSE_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.REQUIRES_NEW_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.REQUIRES_NEW_WITH_END_FALSE_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.SUPPORTS_PATH;
-import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.SUPPORTS_WITH_END_FALSE_PATH;
+import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckInterfaceResource.TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH;
 import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckResource.TCK_LRA_TYPE_RESOURCE_PATH;
+import static org.eclipse.microprofile.lra.tck.participant.api.LRATypeTckSuperclassResource.TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
@@ -77,7 +70,7 @@ import static org.junit.Assert.assertTrue;
 @RunWith(Arquillian.class)
 public class TckLRATypeTests extends TckTestBase {
     private static final Logger LOGGER = Logger.getLogger(TckLRATypeTests.class.getName());
-    
+
     @Deployment(name = "lra-type-tck-tests")
     public static WebArchive deploy() {
         return deploy(TckLRATypeTests.class.getSimpleName().toLowerCase());
@@ -93,149 +86,480 @@ public class TckLRATypeTests extends TckTestBase {
         NONE, NOT_PRESENT, EQUALS, NOT_EQUALS
     }
 
+    // LRA annotations placed on the resource class (see LRATypeTckResource)
+
     @Test
     public void requiredWithLRA() {
-        resourceRequest(REQUIRED_PATH, true, 200, MethodLRACheck.EQUALS, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.REQUIRED_PATH,
+            true, 200, MethodLRACheck.EQUALS, false);
     }
 
     @Test
     public void requiredWithoutLRA() {
-        resourceRequest(REQUIRED_PATH, false, 200, MethodLRACheck.NOT_EQUALS, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.REQUIRED_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, false);
     }
 
     @Test
     public void requiresNewWithLRA() {
-        resourceRequest(REQUIRES_NEW_PATH, true, 200, MethodLRACheck.NOT_EQUALS, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.REQUIRES_NEW_PATH,
+            true, 200, MethodLRACheck.NOT_EQUALS, false);
     }
 
     @Test
     public void requiresNewWithoutLRA() {
-        resourceRequest(REQUIRES_NEW_PATH, false, 200, MethodLRACheck.NOT_EQUALS, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.REQUIRES_NEW_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, false);
     }
 
     @Test
     public void mandatoryWithLRA() {
-        resourceRequest(MANDATORY_PATH, true, 200, MethodLRACheck.EQUALS, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.MANDATORY_PATH,
+            true, 200, MethodLRACheck.EQUALS, false);
     }
 
     @Test
     public void mandatoryWithoutLRA() {
-        resourceRequest(MANDATORY_PATH, false, 412, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.MANDATORY_PATH,
+            false, 412, MethodLRACheck.NOT_PRESENT, false);
     }
 
     @Test
     public void supportsWithLRA() {
-        resourceRequest(SUPPORTS_PATH, true, 200, MethodLRACheck.EQUALS, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.SUPPORTS_PATH,
+            true, 200, MethodLRACheck.EQUALS, false);
     }
 
     @Test
     public void supportsWithoutLRA() {
-        resourceRequest(SUPPORTS_PATH, false, 200, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.SUPPORTS_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
     }
 
     @Test
     public void notSupportedWithRA() {
-        resourceRequest(NOT_SUPPORTED_PATH, true, 200, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.NOT_SUPPORTED_PATH,
+            true, 200, MethodLRACheck.NOT_PRESENT, false);
     }
 
     @Test
     public void notSupportedWithoutLRA() {
-        resourceRequest(NOT_SUPPORTED_PATH, false, 200, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.NOT_SUPPORTED_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
     }
 
     @Test
     public void neverWithLRA() {
-        resourceRequest(NEVER_PATH, true, 412, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.NEVER_PATH,
+            true, 412, MethodLRACheck.NOT_PRESENT, false);
     }
 
     @Test
     public void neverWithInvalidLRA() {
-
-        resourceRequest(NEVER_PATH, true, 412, MethodLRACheck.NOT_PRESENT, false);
-
-        Invocation.Builder target = tckSuiteTarget.path(TCK_LRA_TYPE_RESOURCE_PATH)
-                .path(NEVER_PATH).request();
-        // Anything in the header means that Type.NEVER must fail
-        target = target.header(LRA.LRA_HTTP_CONTEXT_HEADER, "http://something/like/an/URI");
-
-        Response response = target.get();
-
-        assertEquals(testName.getMethodName() + ": Unexpected status", 412, response.getStatus());
-
-        response.close();
+        neverWithInvalidLRA(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.NEVER_PATH);
     }
 
     @Test
     public void neverWithoutLRA() {
-        resourceRequest(NEVER_PATH, false, 200, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.NEVER_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
     }
 
-    // same set of tests except that the invoked method has end = false set on the LRA annotation
-
     @Test
     public void requiredEndWithLRA() {
-        resourceRequest(REQUIRED_WITH_END_FALSE_PATH, true, 200, MethodLRACheck.EQUALS, true);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.REQUIRED_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.EQUALS, true);
     }
 
     @Test
     public void requiredEndWithoutLRA() {
-        resourceRequest(REQUIRED_WITH_END_FALSE_PATH, false, 200, MethodLRACheck.NOT_EQUALS, true);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.REQUIRED_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, true);
     }
 
     @Test
     public void requiresEndNewWithLRA() {
-        resourceRequest(REQUIRES_NEW_WITH_END_FALSE_PATH, true, 200, MethodLRACheck.NOT_EQUALS, true);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.REQUIRES_NEW_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.NOT_EQUALS, true);
     }
 
     @Test
     public void requiresEndNewWithoutLRA() {
-        resourceRequest(REQUIRES_NEW_WITH_END_FALSE_PATH, false, 200, MethodLRACheck.NOT_EQUALS, true);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.REQUIRES_NEW_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, true);
     }
 
     @Test
     public void mandatoryEndWithLRA() {
-        resourceRequest(MANDATORY_WITH_END_FALSE_PATH, true, 200, MethodLRACheck.EQUALS, true);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.MANDATORY_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.EQUALS, true);
     }
 
     @Test
     public void mandatoryEndWithoutLRA() {
-        resourceRequest(MANDATORY_WITH_END_FALSE_PATH, false, 412, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.MANDATORY_WITH_END_FALSE_PATH,
+            false, 412, MethodLRACheck.NOT_PRESENT, false);
     }
 
     @Test
     public void supportsEndWithLRA() {
-        resourceRequest(SUPPORTS_WITH_END_FALSE_PATH, true, 200, MethodLRACheck.EQUALS, true);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.SUPPORTS_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.EQUALS, true);
     }
 
     @Test
     public void supportsEndWithoutLRA() {
-        resourceRequest(SUPPORTS_WITH_END_FALSE_PATH, false, 200, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.SUPPORTS_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
     }
 
     @Test
     public void notSupportedEndWithRA() {
-        resourceRequest(NOT_SUPPORTED_WITH_END_FALSE_PATH, true, 200, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.NOT_SUPPORTED_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.NOT_PRESENT, false);
     }
 
     @Test
     public void notSupportedEndWithoutLRA() {
-        resourceRequest(NOT_SUPPORTED_WITH_END_FALSE_PATH, false, 200, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.NOT_SUPPORTED_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
     }
 
     @Test
-    public void neverWithEndRA() {
-        resourceRequest(NEVER_WITH_END_FALSE_PATH, true, 412, MethodLRACheck.NOT_PRESENT, false);
+    public void neverWithEndLRA() {
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.NEVER_WITH_END_FALSE_PATH,
+            true, 412, MethodLRACheck.NOT_PRESENT, false);
     }
 
     @Test
     public void neverWithoutEndLRA() {
-        resourceRequest(NEVER_WITH_END_FALSE_PATH, false, 200, MethodLRACheck.NOT_PRESENT, false);
+        resourceRequest(TCK_LRA_TYPE_RESOURCE_PATH, LRATypeTckResource.NEVER_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    // LRA annotations placed on the interface (see LRATypeTckInterfaceResource)
+
+    @Test
+    public void requiredWithLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.REQUIRED_PATH,
+            true, 200, MethodLRACheck.EQUALS, false);
+    }
+
+    @Test
+    public void requiredWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.REQUIRED_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, false);
+    }
+
+    @Test
+    public void requiresNewWithLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.REQUIRES_NEW_PATH,
+            true, 200, MethodLRACheck.NOT_EQUALS, false);
+    }
+
+    @Test
+    public void requiresNewWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.REQUIRES_NEW_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, false);
+    }
+
+    @Test
+    public void mandatoryWithLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.MANDATORY_PATH,
+            true, 200, MethodLRACheck.EQUALS, false);
+    }
+
+    @Test
+    public void mandatoryWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.MANDATORY_PATH,
+            false, 412, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void supportsWithLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.SUPPORTS_PATH,
+            true, 200, MethodLRACheck.EQUALS, false);
+    }
+
+    @Test
+    public void supportsWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.SUPPORTS_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void notSupportedWithRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.NOT_SUPPORTED_PATH,
+            true, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void notSupportedWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.NOT_SUPPORTED_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void neverWithLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.NEVER_PATH,
+            true, 412, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void neverWithInvalidLRAAtInterface() {
+        neverWithInvalidLRA(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.NEVER_PATH);
+    }
+
+    @Test
+    public void neverWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.NEVER_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void requiredEndWithLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.REQUIRED_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.EQUALS, true);
+    }
+
+    @Test
+    public void requiredEndWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.REQUIRED_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, true);
+    }
+
+    @Test
+    public void requiresEndNewWithLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.REQUIRES_NEW_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.NOT_EQUALS, true);
+    }
+
+    @Test
+    public void requiresEndNewWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.REQUIRES_NEW_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, true);
+    }
+
+    @Test
+    public void mandatoryEndWithLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.MANDATORY_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.EQUALS, true);
     }
-    
+
+    @Test
+    public void mandatoryEndWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.MANDATORY_WITH_END_FALSE_PATH,
+            false, 412, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void supportsEndWithLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.SUPPORTS_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.EQUALS, true);
+    }
+
+    @Test
+    public void supportsEndWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.SUPPORTS_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void notSupportedEndWithRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.NOT_SUPPORTED_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void notSupportedEndWithoutLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.NOT_SUPPORTED_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void neverWithEndLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.NEVER_WITH_END_FALSE_PATH,
+            true, 412, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void neverWithoutEndLRAAtInterface() {
+        resourceRequest(TCK_LRA_TYPE_INTERFACE_RESOURCE_PATH, LRATypeTckInterface.NEVER_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    // LRA annotations placed on the superclass (see LRATypeTckSuperclassResource)
+
+    @Test
+    public void requiredWithLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.REQUIRED_PATH,
+            true, 200, MethodLRACheck.EQUALS, false);
+    }
+
+    @Test
+    public void requiredWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.REQUIRED_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, false);
+    }
+
+    @Test
+    public void requiresNewWithLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.REQUIRES_NEW_PATH,
+            true, 200, MethodLRACheck.NOT_EQUALS, false);
+    }
+
+    @Test
+    public void requiresNewWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.REQUIRES_NEW_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, false);
+    }
+
+    @Test
+    public void mandatoryWithLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.MANDATORY_PATH,
+            true, 200, MethodLRACheck.EQUALS, false);
+    }
+
+    @Test
+    public void mandatoryWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.MANDATORY_PATH,
+            false, 412, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void supportsWithLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.SUPPORTS_PATH,
+            true, 200, MethodLRACheck.EQUALS, false);
+    }
+
+    @Test
+    public void supportsWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.SUPPORTS_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void notSupportedWithRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.NOT_SUPPORTED_PATH,
+            true, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void notSupportedWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.NOT_SUPPORTED_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void neverWithLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.NEVER_PATH,
+            true, 412, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void neverWithInvalidLRAAtSuperclass() {
+        neverWithInvalidLRA(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.NEVER_PATH);
+    }
+
+    @Test
+    public void neverWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.NEVER_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void requiredEndWithLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.REQUIRED_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.EQUALS, true);
+    }
+
+    @Test
+    public void requiredEndWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.REQUIRED_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, true);
+    }
+
+    @Test
+    public void requiresEndNewWithLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.REQUIRES_NEW_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.NOT_EQUALS, true);
+    }
+
+    @Test
+    public void requiresEndNewWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.REQUIRES_NEW_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_EQUALS, true);
+    }
+
+    @Test
+    public void mandatoryEndWithLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.MANDATORY_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.EQUALS, true);
+    }
+
+    @Test
+    public void mandatoryEndWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.MANDATORY_WITH_END_FALSE_PATH,
+            false, 412, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void supportsEndWithLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.SUPPORTS_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.EQUALS, true);
+    }
+
+    @Test
+    public void supportsEndWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.SUPPORTS_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void notSupportedEndWithRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.NOT_SUPPORTED_WITH_END_FALSE_PATH,
+            true, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void notSupportedEndWithoutLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.NOT_SUPPORTED_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void neverWithEndLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.NEVER_WITH_END_FALSE_PATH,
+            true, 412, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    @Test
+    public void neverWithoutEndLRAAtSuperclass() {
+        resourceRequest(TCK_LRA_TYPE_SUPERCLASS_RESOURCE_PATH, LRATypeTckSuperclass.NEVER_WITH_END_FALSE_PATH,
+            false, 200, MethodLRACheck.NOT_PRESENT, false);
+    }
+
+    private void neverWithInvalidLRA(String rootPath, String path) {
+
+        resourceRequest(rootPath, path, true, 412, MethodLRACheck.NOT_PRESENT, false);
+
+        Invocation.Builder target = tckSuiteTarget.path(rootPath)
+            .path(path).request();
+        // Anything in the header means that Type.NEVER must fail
+        target = target.header(LRA.LRA_HTTP_CONTEXT_HEADER, "http://something/like/an/URI");
+
+        Response response = target.get();
+
+        assertEquals(testName.getMethodName() + ": Unexpected status", 412, response.getStatus());
+
+        response.close();
+    }
+
     /**
      * Perform a JAX-RS resource request and check the resulting status and whether or not it ran with
      * the correct LRA context.
      *
+     * @param rootPath the root path of the JAX-RS resource to invoke
      * @param path the resource path of the JAX-RS method to invoke
      * @param startLRA indicates whether or not an active context should be present on the request
      * @param expectedStatus the expected JAX-RS status code in the response
@@ -244,9 +568,9 @@ public class TckLRATypeTests extends TckTestBase {
      * @param methodLRAShouldBeActive if true the LRA started by the invoked method should still
      *                               be active after the resource invocation completes
      */
-    private String resourceRequest(String path, boolean startLRA, int expectedStatus, MethodLRACheck lraCheckType,
+    private String resourceRequest(String rootPath, String path, boolean startLRA, int expectedStatus, MethodLRACheck lraCheckType,
                                  boolean methodLRAShouldBeActive) {
-        Invocation.Builder target = tckSuiteTarget.path(TCK_LRA_TYPE_RESOURCE_PATH)
+        Invocation.Builder target = tckSuiteTarget.path(rootPath)
                 .path(path).request();
         URI lra = startLRA ? lraClient.startLRA(null, lraClientId(), lraTimeout(), ChronoUnit.MILLIS) : null;
 
@@ -302,7 +626,7 @@ public class TckLRATypeTests extends TckTestBase {
             if (lra != null) {
                 lraClient.closeLRA(lra);
             }
-            
+
             return methodLraId;
         } catch (Throwable e) {
             LOGGER.warning(e.getMessage());