if (enforceOrder) {
      checkForStartEvent(e)
    }

    eventsForMatching.offer(e)
    eventSequence.offer(e)
  }

  private fun checkForStartEvent(e: CallEvent) {
    if (eventsForMatching.isEmpty()) {
      assertThat(e).matchesPredicate { it is CallStart || it is Canceled }
    } else {
      eventsForMatching.forEach loop@{
        when (e.closes(it)) {
          null -> return // no open event

            status.append(")");
        }

        return status.toString();
    }

    private String resourceName(String resourceName) {
        if (resourceName == null || resourceName.trim().isEmpty()) {
            return "";
        }
        final int pos = resourceName.lastIndexOf("/");
        if (pos == -1 || pos == resourceName.length() - 1) {
            return "";
        }

            assertEquals(expectedServer, result.getServer());
            // The implementation returns empty strings as empty strings, not null
            assertEquals(expectedShare.isEmpty() ? "" : expectedShare, result.getShare());
            assertEquals(expectedPath.isEmpty() ? "" : expectedPath, result.getPath());
        }

        @Test
        @DisplayName("Should handle path with multiple backslashes")

    return new EntrySet();
  }

  @Override
  int distinctElements() {
    return countMap.size();
  }

  @Override
  public boolean isEmpty() {
    return countMap.isEmpty();
  }

  @Override
  Iterator<Entry<E>> entryIterator() {
    // AbstractIterator makes this fairly clean, but it doesn't support remove(). To support

    List<String> transformedList = transform(SOME_LIST, SOME_FUNCTION);
    assertFalse(transformedList.isEmpty());
  }

  public void testTransformSequentialIsNotEmpty() {
    List<String> transformedList = transform(SOME_SEQUENTIAL_LIST, SOME_FUNCTION);
    assertFalse(transformedList.isEmpty());
  }

  public void testTransformListIteratorRandomAccess() {

        queue.add(ownerClass.getSuperClass());
        queue.addAll(ownerClass.getInterfaces());

        String overrideSignature = getOverrideSignature();

        while (!queue.isEmpty()) {
            ClassMetaData cl = queue.removeFirst();
            if (cl == null) {
                continue;
            }
            MethodMetaData overriddenMethod = cl.findDeclaredMethod(overrideSignature);

    assertEquals(0, service.startUpCalled);
    assertEquals(0, service.shutDownCalled);
    assertEquals(Service.State.TERMINATED, service.state());
    assertThat(service.transitionStates).isEmpty();
  }

  public void testStop_afterStart() {
    TestService service = new TestService();
    service.startAsync().awaitRunning();
    assertEquals(1, service.startUpCalled);

  abstract String normalizeWord(String word);

  String normalizeFirstWord(String word) {
    return normalizeWord(word);
  }

  private static String firstCharOnlyToUpper(String word) {
    return word.isEmpty()
        ? word
        : Ascii.toUpperCase(word.charAt(0)) + Ascii.toLowerCase(word.substring(1));
  }

        super(source, cliManager, commandLine);
    }

    @Override
    @Nonnull
    public Optional<List<String>> goals() {
        if (!commandLine.getArgList().isEmpty()) {
            return Optional.of(commandLine.getArgList());
        }
        return Optional.empty();
    }

    @Override
    @Nonnull
    public Optional<String> modelVersion() {

            } else if (logger.isDebugEnabled()) {
                logger.debug("Existed URL: Session ID: {}, UrlQueue: {}", sessionId, urlQueue);
            }
        }
        if (!targetList.isEmpty()) {
            insertAll(targetList.stream()
                    .filter(urlQueue -> StringUtil.isNotBlank(urlQueue.getSessionId()) && StringUtil.isNotBlank(urlQueue.getUrl()))