docs: public static void validateWebServiceRef(WebServiceRef wsRef, Class<?> declaringClass, Annotated annotated) {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.entry(tc, "validateWebServiceRef", new Object[] { wsRef, declaringClass, Util.identity(annotated) });
          }
          Class<?> ipClass = getInjectedClass(annotated);
          /*
           * note: Thorough WebService validation is performed later, by
           * com.ibm.ws.jaxws.client.injection.WebServiceRefProcessor.validateAndSetMemberLevelWebServiceRef()
           * This method performs a limited subset of that validation, in order to get the CDI CTS test to pass.
           * It would perhaps be better for us to delegate to WebServiceRefProcessor.validateAndSetMemberLevelWebServiceRef().
           */
          if (!wsRef.lookup().isEmpty()) {
              // If there's a lookup specified, don't validate
              return;
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(tc, "Validating WebServiceRef injection point", wsRef);
          }
  
          Class<?> serviceClass = wsRef.value();
  
          // The injected type is determined by the field type and the attribute type parameter
          // It has already been validated that they are compatible, we want whichever is the subclass of the other
          Class<?> effectiveClass = ipClass;
          if (ipClass.isAssignableFrom(wsRef.type())) {
              effectiveClass = wsRef.type();
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(tc, "Found service type and effective injection types", serviceClass, effectiveClass);
          }
  
          if (Service.class.isAssignableFrom(effectiveClass)) {
              if (effectiveClass.getName().equals(Service.class.getName())) {
                  if (!Service.class.isAssignableFrom(serviceClass) || serviceClass.getName().equals(Service.class.getName())) {
                      throwDefinitionException(declaringClass, annotated);
                  }
              } else {
                  if (!serviceClass.getName().equals(effectiveClass.getName()) && !serviceClass.getName().equals(Service.class.getName())) {
  
                      // We're injecting a service object, field should match service class
                      //if (!effectiveClass.isAssignableFrom(serviceClass)) {
                      throwDefinitionException(declaringClass, annotated);
                  }
              }
          } else {
              // We're injecting a port type
              // Enumerate the port types
              Set<Class<?>> portTypes = new HashSet<Class<?>>();
              for (Method method : serviceClass.getMethods()) {
                  if (method.getAnnotation(WebEndpoint.class) != null) {
                      portTypes.add(method.getReturnType());
                  }
              }
  
              // Check that the effective class matches one of the port types
              if (!portTypes.isEmpty()) {
                  for (Class<?> endpointType : portTypes) {
                      if (effectiveClass.isAssignableFrom(endpointType)) {
                          // There is an endpoint type matching the injection point type
                          return;
                      }
                  }
                  // There were endpoint types but none of them matched the injection point type
                  throwDefinitionException(declaringClass, annotated);
              }
  
          }
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.exit(tc, "validateWebServiceRef");
          }
      }