docs: public void inject(Object objectToInject,
                         InjectionTargetContext targetContext) throws InjectionException {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && tc.isEntryEnabled())
              Tr.entry(tc, "inject : " + getMember() + " : " +
                           Util.identity(objectToInject) + ", " + targetContext);
  
          Object injectedObject = ivInjectionBinding.getInjectableObject(objectToInject,
                                                                         targetContext);
  
          try {
              if (isTraceOn && tc.isDebugEnabled())
                  Tr.debug(tc, "injecting " + Util.identity(injectedObject));
  
              injectMember(objectToInject, injectedObject);
          } catch (IllegalArgumentException ex) // RTC105173
          {
              FFDCFilter.processException(ex, CLASS_NAME + ".inject", "140", this,
                                          new Object[] { objectToInject, targetContext, injectedObject, ivInjectionBinding });
              String msg = Tr.formatMessage(tc,
                                            "INCOMPATIBLE_INJECTED_OBJECT_TYPE_CWNEN0074E",
                                            injectedObject.getClass().getName(),
                                            ivInjectionBinding.getDisplayName(),
                                            getMember());
              InjectionException targetEx = new InjectionException(msg, ex);
              if (isTraceOn && tc.isEntryEnabled()) {
                  final Class<?>[] types = getInjectionClassTypes();
                  final Object[] injectedObjects = getInjectedObjects(injectedObject);
  
                  // Include the relevant ClassLoader in the trace.          RTC118506
                  String debug = AccessController.doPrivileged(new PrivilegedAction<String>() {
                      @Override
                      public String run() {
                          StringBuilder sb = new StringBuilder();
                          for (int i = 0, end = Math.max(types.length, injectedObjects.length); i < end; i++) {
                              if (i != 0) {
                                  sb.append(", ");
                              }
                              sb.append('[').append(i).append(']');
  
                              sb.append(" type=");
                              Class<?> type;
                              if (i < types.length) {
                                  type = types[i];
                                  // getClassLoader requires permission.
                                  sb.append(type.getName()).append(" (loader=").append(type.getClassLoader()).append(')');
                              } else {
                                  type = null;
                                  sb.append("error");
                              }
  
                              sb.append(" object=");
  
                              Class<?> injectedObjectType;
                              if (i < injectedObjects.length) {
                                  boolean assignable;
  
                                  Object injectedObject = injectedObjects[i];
                                  if (injectedObject == null) {
                                      assignable = type != null && !type.isPrimitive();
                                      sb.append("null");
                                  } else {
                                      injectedObjectType = injectedObjects[i].getClass();
                                      assignable = type != null && type.isAssignableFrom(injectedObjectType);
                                      // getClassLoader requires permission.
                                      sb.append(injectedObjectType.getName()).append(" (loader=").append(injectedObjectType.getClassLoader()).append(')');
                                  }
  
                                  if (type != null) {
                                      sb.append(" assignable=").append(assignable);
                                  }
                              } else {
                                  sb.append("error");
                              }
                          }
  
                          return sb.toString();
                      }
                  });
  
                  Tr.exit(tc, "inject : " + debug + " : " + targetEx);
              }
              throw targetEx;
          } catch (Throwable ex) {
              FFDCFilter.processException(ex, CLASS_NAME + ".inject",
                                          "97", this, new Object[] { objectToInject, targetContext, injectedObject, ivInjectionBinding });
  
              // All exceptions returned through a reflect method call are wrapped,
              // making it difficult to debug a problem since InovcationTargetEx
              // does not print the root exception. Unwrap the 'target' exception
              // so that the client will see it as the cause of the
              // InjectionException.                                        d534353.1
              Throwable targetEx = ex;
   
              //Unwrap ManagedObjectException before checking for InvocationTargetException. Use the class name to avoid a compile time dependency.
              if (ex.getClass().getName().equals("com.ibm.ws.managedobject.ManagedObjectException")) {
                  Throwable unwrappedEx = ex.getCause();
                  if (unwrappedEx != null)
                      ex = unwrappedEx;
              }
  
              if (ex instanceof InvocationTargetException) {
                  targetEx = ex.getCause();
                  if (targetEx == null)
                      targetEx = ex;
              }
  
              String name = ivInjectionBinding.getDisplayName();
              InjectionException iex = new InjectionException("The injection engine encountered an error injecting " +
                                                              name + " into " + getMember() + ": " + targetEx, targetEx);
              Tr.error(tc, "INJECTION_FAILED_CWNEN0028E",
                       name, getMember(), targetEx.getMessage());
              if (isTraceOn && tc.isEntryEnabled())
                  Tr.exit(tc, "inject : " + targetEx);
              throw iex;
          }
  
          if (isTraceOn && tc.isEntryEnabled())
              Tr.exit(tc, "inject : " + ivInjectionBinding.getDisplayName() + " : " +
                          Util.identity(injectedObject));
      }