ImmutableGraph<String> graph = GraphBuilder.directed().<String>immutable().addNode("A").build();

    assertThat(graph.nodes()).containsExactly("A");
    assertThat(graph.edges()).isEmpty();
  }

  @Test
  public void immutableGraphBuilder_putEdgeFromNodes() {
    ImmutableGraph<String> graph =
        GraphBuilder.directed().<String>immutable().putEdge("A", "B").build();

                    if (analyzedFields != null && !analyzedFields.isEmpty()) {
                        String[] fields = analyzedFields.split(",");
                        for (String field : fields) {
                            String trimmedField = field.trim();
                            if (!trimmedField.isEmpty()) {
                                notAnalyzedFieldSet.remove(trimmedField);

    synchronized(this) {
      code = receivedCloseCode
      reason = receivedCloseReason

      readerToClose = reader
      reader = null

      if (enqueuedClose && messageAndCloseQueue.isEmpty()) {
        // Close the writer on the writer's thread.
        val writerToClose = this.writer
        if (writerToClose != null) {
          this.writer = null

        assertNotNull(queryBuilder);

        // Should not add empty highlight
        assertTrue(queryContext.getHighlightedQuerySet().isEmpty());
    }

    public void test_execute_withWildcardQuery() throws Exception {
        QueryContext queryContext = new QueryContext("test*", false);

   * SortedMultiset#contains}, {@link SortedMultiset#containsAll}, {@link SortedMultiset#count},
   * {@link SortedMultiset#firstEntry} {@link SortedMultiset#headMultiset}, {@link
   * SortedMultiset#isEmpty}, {@link SortedMultiset#lastEntry}, {@link SortedMultiset#subMultiset},
   * {@link SortedMultiset#tailMultiset}, the {@code size()} and {@code iterator()} methods of

      }
    } else {
      elements[dstIndex] = null;
      entries[dstIndex] = 0;
    }
  }

  int firstEntryIndex() {
    return isEmpty() ? -1 : 0;
  }

  int getSuccessor(int entryIndex) {
    return (entryIndex + 1 < size) ? entryIndex + 1 : -1;
  }

  /**

        for (CrawlerStatus status : CrawlerStatus.values()) {
            String description = getStatusDescription(status);
            assertNotNull(description);
            assertFalse(description.isEmpty());
        }
    }

    /**
     * Helper method to test switch statement
     */
    private String getStatusDescription(CrawlerStatus status) {
        switch (status) {
        case INITIALIZING:

    /**
     * Checks if any sort builders have been added to this context.
     * @return True if sort builders are present, false otherwise.
     */
    public boolean hasSorts() {
        return !sortBuilderList.isEmpty();
    }

    /**
     * Gets the list of sort builders for this query context.
     * @return The list of sort builders.
     */
    public List<SortBuilder<?>> sortBuilders() {

    Thread.setDefaultUncaughtExceptionHandler { _, throwable ->
      initUncaughtException(throwable)
    }

    taskQueuesWereIdle = TaskRunner.INSTANCE.activeQueues().isEmpty()

    applyLogger {
      addHandler(testLogHandler)
      level = Level.FINEST
      useParentHandlers = false
    }
  }

  @SuppressLint("NewApi")

     * @return a new string with invalid XML characters removed, or the original
     *         string if it is empty
     */
    public static String stripInvalidXMLCharacters(final String in) {
        if (StringUtil.isEmpty(in)) {
            return in;
        }

        final StringBuilder buf = new StringBuilder(in.length());
        char c;
        for (int i = 0; i < in.length(); i++) {
            c = in.charAt(i);