checks if actualEntry contains the activeMenuName in entry itself and its
sub entries

@param activeMenuName
@param actualEntry current iterated object
@return
772062
public boolean isActiveInMenuTree(MenuEntry activeMenu, MenuEntry actualEntry) {
		return actualEntry.flattened().anyMatch(
				entry -> checkForNull(entry, activeMenu) ? entry.getName().equals(activeMenu.getName()): false);
	}
910898
protected boolean isItemAccepted(byte[] key) {
        boolean entryAccepted = false;
        if (!fetchOrphaned) {
            if (isKeyNeeded(key)) {
                entryAccepted = true;
            }
        } else {
            if (!StoreRoutingPlan.checkKeyBelongsToNode(key, nodeId, initialCluster, storeDef)) {
                entryAccepted = true;
            }
        }
        return entryAccepted;
    }
526960
public boolean hasConsumersAttached()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "hasConsumersAttached");

        //Does the consumer list have any elements? If so return true, else false
        boolean hasConsumersAttached = (getConsumerCount() > 0);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "hasConsumersAttached", Boolean.valueOf(hasConsumersAttached));

        return hasConsumersAttached;
    }
1088135
@Override
  public List<AclEntry> getEntries() {
    if (isEmpty()) {
      return new ArrayList<>();
    }
    List<AclEntry> aclEntryList = super.getEntries();

    for (AclEntry entry : aclEntryList) {
      entry.setDefault(true);
    }
    return aclEntryList;
  }
159901
public boolean isParent(RegistryEntry registryEntry) {
		RegistryEntry entry = getParentRegistryEntry();
		while (entry != null) {
			if (entry.equals(registryEntry)) {
				return true;
			}
			entry = entry.getParentRegistryEntry();
		}
		return false;
	}
717442
@Override
    public boolean forEachEntryWhile(Predicate<? super SetEntry<E>> predicate) {
        Objects.requireNonNull(predicate);
        return m.forEachEntryWhile(e -> predicate.test(((SetEntry<E>) e)));
    }
1144515
boolean contains(ProtoMember protoMember) {
    if (protoMember == null) throw new NullPointerException("protoMember == null");
    if (identifierSet.excludes(protoMember)) return false;
    return members.containsKey(protoMember.type())
        ? members.containsEntry(protoMember.type(), protoMember)
        : types.contains(protoMember.type());
  }
183340
@Override
    public boolean contains(final ENTRY entry) throws CouldNotPerformException {
        if (entry == null) {
            throw new NotAvailableException("entry");
        }
        return contains(entry.getId());
    }
334139
public function searchMenuEntryForKey($menuEntries, $key)
    {
        foreach ($menuEntries as $menuEntry) {
            if ($menuEntry->getKey() === $key) {
                return $menuEntry;
            } 
            
            if ($menuEntry->hasChildren()) {
                $result = $this->searchMenuEntryForKey($menuEntry->getChildren(), $key);
                
                if ($result !== false) {
                    return $result;
                }
            }
        }
        
        return false;
    }
306029
public void hasFirstEntry(@NullableDecl Object key, @NullableDecl Object value) {
    Entry<Object, Object> expectedEntry = Maps.immutableEntry(key, value);
    if (actualAsNavigableMap().isEmpty()) {
      failWithActual("expected to have first entry", expectedEntry);
      return;
    }

    Entry<?, ?> actualFirstEntry = actualAsNavigableMap().firstEntry();
    if (!Objects.equal(actualFirstEntry, expectedEntry)) {
      Object actualFirstKey = actualFirstEntry.getKey();
      if (actualAsNavigableMap().entrySet().contains(expectedEntry)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s has first entry <%s>. "
                        + "It does contain this entry, but the first entry is <%s>",
                    actualAsString(), expectedEntry, actualFirstEntry)));
      } else if (Objects.equal(actualFirstKey, key)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s has first entry <%s>, the first value is <%s>",
                    actualAsString(), expectedEntry, actualFirstEntry.getValue())));
      } else if (Objects.equal(actualFirstEntry.getValue(), value)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s has first entry <%s>, the first key is <%s>",
                    actualAsString(), expectedEntry, actualFirstKey)));
      } else if (actualAsNavigableMap().containsKey(key)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s has first entry <%s>. It does contain this key, "
                        + "but the key is mapped to <%s>, and the first entry is <%s>",
                    actualAsString(),
                    expectedEntry,
                    actualAsNavigableMap().get(key),
                    actualFirstEntry)));
      } else if (actualAsNavigableMap().containsValue(value)) {
        Set<Object> keys = new LinkedHashSet<>();
        for (Entry<?, ?> actualEntry : actualAsNavigableMap().entrySet()) {
          if (Objects.equal(actualEntry.getValue(), value)) {
            keys.add(actualEntry.getKey());
          }
        }
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s has first entry <%s>. It does contain this value, but the "
                        + "value is mapped from the keys <%s>, and the first entry is <%s>",
                    actualAsString(), expectedEntry, keys, actualFirstEntry)));
      } else {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s has first entry <%s>. "
                        + "It does not contain this entry, and the first entry is <%s>",
                    actualAsString(), expectedEntry, actualFirstEntry)));
      }
    }
  }
923024
public static <K, V> Predicate<Map<K, V>> anyEntry(
      Predicate<? super Map.Entry<K, V>> p) {
    return forEntries(Predicates.<Map.Entry<K, V>>any(p));
  }
180537
protected I_CmsContextMenuEntry createViewOnlineEntry() {

        final String onlineLink = m_controller.getData().getOnlineLink();
        CmsContextMenuEntry entry = null;
        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(onlineLink)) {
            I_CmsContextMenuCommand command = new I_CmsContextMenuCommand() {

                public void execute(
                    CmsUUID structureId,
                    I_CmsContextMenuHandler handler,
                    CmsContextMenuEntryBean bean) {

                    Window.open(onlineLink, "opencms-online", null);
                }

                public A_CmsContextMenuItem getItemWidget(
                    CmsUUID structureId,
                    I_CmsContextMenuHandler handler,
                    CmsContextMenuEntryBean bean) {

                    return null;
                }

                public boolean hasItemWidget() {

                    return false;
                }
            };
            entry = new CmsContextMenuEntry(this, null, command);
            CmsContextMenuEntryBean entryBean = new CmsContextMenuEntryBean();
            entryBean.setLabel(Messages.get().key(Messages.GUI_VIEW_ONLINE_0));
            entryBean.setActive(true);
            entryBean.setVisible(true);
            entry.setBean(entryBean);
        }
        return entry;
    }
828510
@CanIgnoreReturnValue
  public Ordered containsAtLeastEntriesIn(Map<?, ?> expectedMap) {
    if (expectedMap.isEmpty()) {
      return IN_ORDER;
    }
    boolean containsAnyOrder =
        containsEntriesInAnyOrder(expectedMap, "contains at least", /* allowUnexpected= */ true);
    if (containsAnyOrder) {
      return new MapInOrder(expectedMap, "contains at least these entries in order");
    } else {
      return ALREADY_FAILED;
    }
  }
678001
@SuppressWarnings("unchecked") // worse case should be a ClassCastException
  /*
   * TODO(cpovirk): Consider requiring key to be a K here. But AtomicLongMapSubject isn't currently
   * parameterized, and if we're going to add a type parameter, I'd rather wait until after we
   * (hopefully) remove the other existing type parameters.
   */
  public void containsEntry(Object key, long value) {
    checkNotNull(key, "AtomicLongMap does not support null keys");
    long actualValue = ((AtomicLongMap<Object>) actual()).get(key);
    if (actualValue != value) {
      failWithActual("expected to contain entry", immutableEntry(key, value));
    }
  }
144212
public boolean isMatchingAny() {
        if (this.levels == null) {
            return false;
        }
        int i = 0;
        int n = this.levelCounter;
        while (n-- != 0) {
            if (this.levels[i].isSelectionActive()) {
                return true;
            }
            i++;
        }
        return false;
    }
68657
public boolean containsEntry(String name) {
    if (src == null) {
      throw new IllegalStateException("Source is not given");
    }
    return ZipUtil.containsEntry(src, name);
  }
927493
public boolean containsEntityEntry(String entityName) {
        if (StringUtils.isBlank(entityName)) {
            throw new IllegalArgumentException("entityName cannot be null or empty.");
        }
        return entries.containsKey(entityName);
    }