}

            @Override
            public String getClassifier() {
                String classifier = dependency.getClassifier();
                if (classifier == null || classifier.isEmpty()) {
                    classifier = getType().getClassifier();
                    if (classifier == null) {
                        classifier = "";
                    }
                }

                allErrors.addAll(findMissingAdocFiles(jsonFile, directoryPath));
                allErrors.addAll(findMissingAnchors(jsonFile, allExistingAnchors));
            }

            if (!allErrors.isEmpty()) {
                System.out.println("Found documentation files or anchors that do not exist:");
                for (String error : allErrors) {
                    System.out.println(error);
                }

     */
    public void crawl(final String sessionId) {
        final List<DataConfig> configList = ComponentUtil.getCrawlingConfigHelper().getAllDataConfigList();

        if (configList.isEmpty()) {
            // nothing
            if (logger.isInfoEnabled()) {
                logger.info("No crawling target data.");
            }
            return;
        }

        sb.append(", message=").append(getMessage());

        if (recoveryHint != null) {
            sb.append(", hint=").append(recoveryHint);
        }

        if (!context.isEmpty()) {
            sb.append(", context=").append(context);
        }

        sb.append("]");
        return sb.toString();
    }

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

  public @Nullable V get(@Nullable Object rowKey, @Nullable Object columnKey) {
    Map<C, V> row = safeGet(rowMap(), rowKey);
    return (row == null) ? null : safeGet(row, columnKey);
  }

  @Override
  public boolean isEmpty() {
    return size() == 0;
  }

  @Override
  public void clear() {
    Iterators.clear(cellSet().iterator());
  }

  @CanIgnoreReturnValue
  @Override

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

    }

    private NetworkInterfaceInfo selectLocalInterface(int index) {
        if (localInterfaces.isEmpty())
            return null;
        return localInterfaces.get(index % localInterfaces.size());
    }

    private NetworkInterfaceInfo selectRemoteInterface(int index) {
        if (remoteInterfaces.isEmpty())
            return null;
        return remoteInterfaces.get(index % remoteInterfaces.size());
    }

    assume().that(network.allowsSelfLoops()).isTrue();

    addNode(N1);
    addEdge(N1, N1, E11);
    assertThat(networkAsMutableNetwork.removeNode(N1)).isTrue();
    assertThat(network.nodes()).isEmpty();
    assertThat(network.edges()).doesNotContain(E11);
  }

  @Test
  public void removeEdge_existingSelfLoopEdge() {
    assume().that(graphIsMutable()).isTrue();

    }

    private
    fun assertLeftoverFilesCleanedUpEventually(vararg leftoverFiles: String) {
        leftoverFiles.forEach {
            assertTrue(projectDir.resolve(it).walk().filter { it.isFile }.toList().isEmpty())
        }
    }

    @Test
    fun `fail build if leftover file found and test passes`() {
        val result = run(":successful-test-with-leftover:test", "--no-watch-fs").buildAndFail()