final ListResultBean<FileConfig> list = fileConfigBhv.selectList(cb -> {
            cb.query().setName_Equal(name);
            cb.query().addOrderBy_SortOrder_Asc();
        });
        if (list.isEmpty()) {
            return OptionalEntity.empty();
        }
        return OptionalEntity.of(list.get(0));
    }

    /**
     * Stores a file configuration in the database.

        getDocumentationRoot().getAsFileTree().matching(spec -> spec.include("**/*.adoc")).forEach(file -> {
            gatherBadSnippetsInFile(file, errors);
        });

        if (!errors.isEmpty()) {
            StringBuilder sb = new StringBuilder("Found reversed multi-language snippet order in AsciiDoc files:\n");
            for (Map.Entry<File, List<Error>> e : errors.entrySet()) {

                .stream()
                .map(MavenProject::getVersion)
                .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
        if (!versions.isEmpty()) {
            return versions;
        }
        return getAllProjects()
                .getOrDefault(artifact.getGroupId(), Collections.emptyMap())

      stackWithLastReturnedElementAtTop = null;
    }

    @Override
    public boolean hasNext() {
      return !nextElements.isEmpty();
    }

    @Override
    public boolean hasPrevious() {
      return !previousElements.isEmpty();
    }

    @Override
    public E next() {
      return transferElement(nextElements, previousElements);
    }

    @Override

    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);