docs: private MCWrapper allocateMCWrapper(ManagedConnectionFactory managedConnectionFactory,
                                          ConnectionRequestInfo requestInfo,
                                          Subject subj,
                                          UOWCoordinator uowCoord) throws ResourceException {
  
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.entry(this, tc, "allocateMCWrapper");
          }
  
          MCWrapper mcWrapper = null;
  
          /*
           * Allocate ManagedConnection using PoolManager, passing the Tx as the affinityId
           */
  
          //  try {
          boolean enforceSerialReuse = false;
          if (shareable && uowCoord != null) { // true sharing detection
              // In 5.0, we're no longer supporting true connection sharing within an LTC.  This was
              // done to be consistent with the JCA spec (connection sharing requires a global
              // transaction) and to prevent "surprises" by sharing when it is not expected.  So,
              // if the returned MC has active handles and we're within an LTC, we're going to
              // force the creation of a new shareable MC.
  
              // Post 5.0, when (if) the JCA spec is updated, we will throw an exception. The
              // exception will be thrown within the SharedPool code.
              if (!uowCoord.isGlobal()) {
                  // We are in a LTC Scope
                  boolean container_at_boundary = ((LocalTransactionCoordinator) uowCoord).isContainerResolved();
                  if (!container_at_boundary) {
                      // The LTC is resolved by the application
                      enforceSerialReuse = true;
                  }
              } // end not isGlobal
          } // end if (shareable...)
  
          // Now that we are using the real null value for the uowCoord, we don't need separate
          //  reserve() invocations for the different "types" of coordinators.  Just call it with the
          //  appropriate parameters and let the reserve() do the right thing.  The reserve() method
          //  requires both a non-null coordinator and the shareable flag set to true to allocate
          //  a connection from the shared pool.
          try {
              mcWrapper = (com.ibm.ejs.j2c.MCWrapper) _pm.reserve(// factory
                                                                  managedConnectionFactory,
                                                                  subj,
                                                                  requestInfo,
                                                                  uowCoord,
                                                                  shareable,
                                                                  enforceSerialReuse,
                                                                  cmConfig.getCommitPriority(),
                                                                  cmConfig.getBranchCoupling());
  
          } catch (ResourceException r) {
  
              if (isTraceOn && tc.isEntryEnabled()) {
                  Tr.exit(this, tc, "allocateMCWrapper");
              }
              throw r;
          }
  
          if (mcWrapper == null) {
              Tr.error(tc, "NULL_MANAGED_CONNECTION_J2CA0015", _pm.gConfigProps.cfName);
              throw new ResourceException("PoolManager returned null ManagedConnection");
          } else {
              if (isTraceOn && tc.isDebugEnabled()) {
                  Tr.debug(this, tc, "Using MCWrapper@" + Integer.toHexString(mcWrapper.hashCode()));
              }
          }
  
          //  this code needed to be moved here after the check managed connection instanceof
  
          // Normally a transaction of some sort is required to use the ConnectionManager
          // However, there are several scenarios to consider:
          //
          // 1. No transaction and dynamic enlistment is not supported.
          //    This is the case that we want to at least put out a debug
          //    message that this is a potential problem that the designer
          //    should look into.
          // 2. No transaction and dynamic enlistment is supported.
          //    This is basically a promise that a transaction will be involved
          //    later when it is actually needed, so not having a transaction
          //    is not a problem at this time.
          if (uowCoord == null) {
  
              if (isTraceOn && tc.isDebugEnabled()) {
                  Tr.debug(this, tc, "Transaction context does NOT exist");
              }
  
              if (!_pm.gConfigProps.isDynamicEnlistmentSupported()) {
  
                  if (isTraceOn && tc.isDebugEnabled()) {
                      Tr.debug(this, tc, "Not marked for dynamic transaction enlistment");
                  }
  
                  // Only log warnings or throw exception for LocalTransaction, XATransaction, and RRSTransactional RAs
                  if (_pm.gConfigProps.transactionSupport != TransactionSupportLevel.NoTransaction) {
                      // deleted check for RRSTransactional support
                      // If the property, logMissingTranContext is not set to false in the j2c.properties file
                      //    (which is the default)
                      //   this is NOT JMS accessing a J2EE resource (such as a JDBC datasource) via
                      //   an EJB at the older 1.1 level
                      // then we want to issue a warning that the transaction context is missing.
                      // So basically, we want to issue a warning except for this earlier case where
                      // not having a transaction context was allowed.
                      if (_pm.gConfigProps.logMissingTranContext) {
                          Tr.warning(tc, "MISSING_TRANSACTION_CONTEXT_J2CA0075", "allocateMCWrapper");
                      }
                      // Remove check for whether connector runtime supports no transaction mode
                  }
              }
          } // end uowCoord == null
            // end of moved code for defect
  
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.exit(this, tc, "allocateMCWrapper");
          }
  
          return mcWrapper;
  
      }