/*
(non-Javadoc)

@see org.jboss.arquillian.warp.spi.LifecycleManagerStore#checkUnbound(org.jboss.arquillian.warp.spi.LifecycleManager)
168435
@Override
    protected <T> void checkUnbound(LifecycleManager manager) throws StoreHasAssociatedObjectsException {
        Tracking tracking = TRACK.get(manager);
        if (tracking != null) {
            if (!tracking.isEmpty()) {
                throw new StoreHasAssociatedObjectsException();
            }
            TRACK.remove(manager);
        }
    }
1318956
def unbounded(self):
        """"""
        self._check_valid()
        return (self._problem._p.get_status() ==
                qsoptex.SolutionStatus.UNBOUNDED)
1182663
public void valueUnbound(HttpSessionBindingEvent event) {
        for (SessionFieldMapper fieldMapper : this.values()) {
            if (fieldMapper.runnable != null) fieldMapper.runnable.cancel();
        }
    }
1323290
boolean detectDeadlock(Locker acquirer, Lock l, int mode) {

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "detectDeadlock", new Object[] { acquirer, l,
                                                         modeStrs[mode] });
        }

        boolean result = false;

        //----------------------------------------------------------------
        // Iterate through the holders of the given lock and determine if
        // any of them are waiting on a lock held by the requestor. If
        // any of them are then a deadlock exists.
        //----------------------------------------------------------------

        Enumeration holders = l.getHolders();
        while (holders.hasMoreElements()) {
            if (lockerWaitingOn((Locker) holders.nextElement(), acquirer)) {
                result = true;
                break;
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "detectDeadlock:" + result);
        }
        return result;

    }
643122
private void checkUnmappedElements(List<T> offspring,
                                       Map<T, T> mapping,
                                       int mappingStart,
                                       int mappingEnd)
    {
        for (int i = 0; i < offspring.size(); i++)
        {
            if (!isInsideMappedRegion(i, mappingStart, mappingEnd))
            {
                T mapped = offspring.get(i);
                while (mapping.containsKey(mapped))
                {
                    mapped = mapping.get(mapped);
                }
                offspring.set(i, mapped);
            }
        }
    }
84682
private void checkDone() {
    if (doneHandler != null) {
      if (cause != null) {
        doneHandler.handle(new DefaultFutureResult<T>(cause));
      } else {
        if (count == required) {
          doneHandler.handle(new DefaultFutureResult<T>((T) null));
        }
      }
    }
  }
1092517
private void tryUnlock(CmsResource resource) {

        try {
            m_cms.unlockResource(resource);
        } catch (Exception unlockError) {
            LOG.debug(unlockError.getLocalizedMessage(), unlockError);
        }
    }
649439
private void checkUnready() {
    if (!allReady()) {
      log.debug(String.format("%s - Components not ready, pausing components", NetworkManager.this));
      data.remove(currentContext.address(), new Handler<AsyncResult<String>>() {
        @Override
        public void handle(AsyncResult<String> result) {
          if (result.failed()) {
            log.error(result.cause());
          }
        }
      });
    }
  }
1184090
@Test
    public void unmanaged_send_and_receive_is_working() throws JMSException {

        testSender2.send("UNMANAGED");

        try {
            unmanaged.await(1, TimeUnit.SECONDS);

            Assertions.assertThat(textUnmanaged).isEqualTo("UNMANAGED");
        } catch (InterruptedException e) {
            fail("Thread interrupted");
        }
    }
139692
@Override
	public boolean isPaused(Trigger trigger) throws SchedulerException {
		return scheduler.getTriggerState(trigger.getKey()) == TriggerState.PAUSED;
	}
392953
public final void commitPersistUnlock(PersistentTransaction transaction) throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "commitPersistUnlock", transaction);

        AbstractItem item = null;
        boolean hasBecomeAvailable = false;
        boolean linkHasBecomeReleasable = false;
        synchronized (this)
        {
            if (ItemLinkState.STATE_UNLOCKING_PERSISTENTLY_LOCKED == _itemLinkState)
            {
                _assertCorrectTransaction(transaction);

                item = getItem();

                ListStatistics stats = getParentStatistics();
                synchronized (stats)
                {
                    stats.decrementLocked();
                    stats.incrementAvailable();
                }

                // Save the item before we change the state
                _lockID = NO_LOCK_ID;
                _unlockCount++;
                linkHasBecomeReleasable = _declareDiscardable();
                _itemLinkState = ItemLinkState.STATE_AVAILABLE;
                hasBecomeAvailable = true;
            }
            else
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                    SibTr.event(this, tc, "Invalid Item state: " + _itemLinkState);
                if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                    SibTr.exit(this, tc, "commitPersistUnlock");
                throw new StateException(_itemLinkState.toString());
            }
            _transactionId = null;
        }
        // this stuff has to be done outside the synchronized block
        if (linkHasBecomeReleasable)
        {
            _declareReleasable(item);
        }

        // PK37596
        // Now we have completed an unlock we have become available again
        // and so need to inform our containing list in case we need to
        // be added to a cursors jumpback list.
        if (hasBecomeAvailable)
        {
            // all items are discardable in avaialable state.
            if (_owningStreamLink != null)
            {
                _owningStreamLink.linkAvailable(this);
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "commitPersistUnlock");
    }
528492
def unbounded(self):
        """"""
        self._check_valid()

        status = self._problem._p.Status
        if (status == gurobipy.GRB.INF_OR_UNBD and
                self._problem._p.params.DualReductions):
            # Disable dual reductions to obtain a definitve answer
            self._problem._p.params.DualReductions = 0
            try:
                self._problem._p.optimize()
            finally:
                self._problem._p.params.DualReductions = 1

            status = self._problem._p.Status
        return status == gurobipy.GRB.UNBOUNDED
841262
public boolean isUnloadedAtDestination() {
		for (HandlingEvent event : deliveryHistory().eventsOrderedByCompletionTime()) {
			if (Type.UNLOAD.equals(event.getType()) && getDestination().equals(event.getLocation())) {
				return true;
			}
		}
		return false;
	}
129025
@Override
    public void eventUnlocked() throws SevereMessageStoreException
    {
        super.eventUnlocked();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "eventUnlocked");

        if (failedInitInRestore)
        {
            //we can only register the listeners if we are fully initialized
            if (stream instanceof DurableSubscriptionItemStream)
            {
                stream.registerListeners(this);
            }
            failedInitInRestore = false;
        }

        reavailable = true;

        try
        {
            // 541867
            // When a message is unlocked, a registered ConsumerDispatcher will try to deliver
            // it to a ready consumer. When this happens the consumer will register for the UNLOCK
            // event. If that is added to a later slot (e.g. UNLOCKED_3) than the one that's currently
            // being processed (the ConsumerDispatcher) it is possible for us to drive the new consumer's
            // unlock event straight away (even though the message has just been locked).

            // This can also result in two (or more) consumers (or multiple instances of the same consumer)
            // being registered on the same message as we may not have deregistered the initial consumer
            // at the time that the ConsumerDispatcher delivers the to the second (or the same) consumer
            // after the unlock.

            // The solution is to proccess all the non-ConsumerDispatchers registered before going back
            // and driving the ConsumerDispatcher.
            for (int pass = 0; pass < 2; pass++)
            {
                if ((UNLOCKED_1 != null) &&
                    (((pass == 0) && !(UNLOCKED_1 instanceof ConsumerDispatcher)) ||
                    ((pass == 1) && (UNLOCKED_1 instanceof ConsumerDispatcher))))
                {
                    UNLOCKED_1.messageEventOccurred(MessageEvents.UNLOCKED, this, null);
                }
                if ((UNLOCKED_2 != null) &&
                    (((pass == 0) && !(UNLOCKED_2 instanceof ConsumerDispatcher)) ||
                    ((pass == 1) && (UNLOCKED_2 instanceof ConsumerDispatcher))))
                {
                    UNLOCKED_2.messageEventOccurred(MessageEvents.UNLOCKED, this, null);
                }
                if ((UNLOCKED_3 != null) &&
                    (((pass == 0) && !(UNLOCKED_3 instanceof ConsumerDispatcher)) ||
                    ((pass == 1) && (UNLOCKED_3 instanceof ConsumerDispatcher))))
                {
                    UNLOCKED_3.messageEventOccurred(MessageEvents.UNLOCKED, this, null);
                }
            }
        } catch (SIException e)
        {
            FFDCFilter.processException(
                                        e,
                                        "com.ibm.ws.sib.processor.impl.store.items.MessageItemReference.eventUnlocked",
                                        "1:574:1.106",
                                        this);

            SibTr.exception(tc, e);

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "eventUnlocked", e);

            throw new SIErrorException(e);
        }
        reavailable = false;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "eventUnlocked");
    }
226427
@Override
    public boolean isHAEnabled() {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "isHAEnabled");

        final boolean haEnabled = Configuration.HAEnabled();

        if (tc.isEntryEnabled())
            Tr.exit(tc, "isHAEnabled", haEnabled);
        return haEnabled;
    }
1138162
private boolean isUnchangedAndShouldBeRemoved(CmsResource item) {

        if (item.getState().isUnchanged()) {
            return !m_keepOriginalUnchangedResources || !m_originalResources.contains(item);
        }
        return false;
    }
360722
@Override
    public boolean onUnbind(Intent intent) {
        LogManager.i(TAG, "unbinding so destroying self");
        this.stopForeground(true);
        this.stopSelf();
        return false;
    }