}, (builder, hit) -> {
                try {
                    final Map<String, Object> doc = hit.getSourceAsMap();
                    final String url = DocumentUtil.getValue(doc, fessConfig.getIndexFieldUrl(), String.class);
                    if (StringUtil.isNotBlank(url)) {
                        final Set<String> labelSet = labelTypeHelper.getMatchedLabelValueSet(url);

                    storeChildUrlsToQueue(urlQueue, getChildUrlSet(searchEngineClient, id));
                    return true;
                }

                final Date expires = DocumentUtil.getValue(document, fessConfig.getIndexFieldExpires(), Date.class);
                if (expires != null && expires.getTime() < systemHelper.getCurrentTimeAsLong()) {

            return null;
        }

        for (final Map.Entry<String, SmbAuthentication> entry : authMap.entrySet()) {
            if (path.startsWith(entry.getKey())) {
                return entry.getValue();
            }
        }
        return null;
    }

     *
     * <p><b>NOTE:</b> The object-graph nagivation actually takes place via the
     * {@link ReflectionValueExtractor} class.</p>
     */
    public Object getValue(String expression) {
        if (expression == null || expression.trim().isEmpty()) {
            return null;
        }

        try {
            return ReflectionValueExtractor.evaluate(expression, root, false);

        testCoverageAndBuckets.associate { testCoverageAndBucket ->
            testCoverageAndBucket as JSONObject
            val testCoverage: TestCoverage = uuidToTestCoverage.getValue(testCoverageAndBucket.getIntValue("testCoverageUuid"))
            val buckets: List<SmallSubprojectBucket> = testCoverageAndBucket.getJSONArray("buckets").map {

        try {
            List<String> list;
            csvReader.readValues(); // ignore header
            while ((list = csvReader.readValues()) != null) {
                String targetWord = getValue(list, 0);
                if (StringUtil.isBlank(targetWord)) {
                    // skip
                    continue;
                }
                try {
                    boolean isDelete = false;

    for (Entry<String, String> entry : TEST_STRINGS.entrySet()) {
      if (testAsByteSource) {
        suite.addTest(
            suiteForBytes(factory, entry.getValue().getBytes(UTF_8), name, entry.getKey(), true));
      } else {
        suite.addTest(suiteForString(factory, entry.getValue(), name, entry.getKey()));
      }
    }
    return suite;
  }

  static TestSuite suiteForBytes(

                parser.setFeature(entry.getKey(), "true".equalsIgnoreCase(entry.getValue()));
            }

            // property
            for (final Map.Entry<String, String> entry : propertyMap.entrySet()) {
                parser.setProperty(entry.getKey(), entry.getValue());
            }
        } catch (final Exception e) {

  }

  private String expectedToString(Set<Entry<K, V>> entries) {
    Map<K, V> reference = new LinkedHashMap<>();
    for (Entry<K, V> entry : entries) {
      reference.put(entry.getKey(), entry.getValue());
    }
    return reference.toString();
  }

                    Map<String, String> map = CompactLinkedHashMap.create();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return map;
                  }
                })
            .named("CompactLinkedHashMap")
            .withFeatures(
                CollectionSize.ANY,