final StringBuilder buf = new StringBuilder(255);
            final XPathNodes nodeList = getXPathAPI().selectNodeList(document, targetNodePath);
            for (int i = 0; i < nodeList.size(); i++) {
                final Node node = nodeList.get(i);
                buf.append(node.getTextContent()).append(' ');
            }
            return new ExtractData(buf.toString().replaceAll("\\s+", " ").trim());

                                                            ${f:h(data.name)}
                                                    </td>
                                                    <td>${f:h(data.size)}</td>
                                                    <td>${fe:formatDate(data.lastModified, 'yyyy-MM-dd HH:mm:ss')}</td>
                                                </c:if>

    ImmutableSet<Class<?>> eventTypes = flattenHierarchy(event.getClass());

    List<Iterator<Subscriber>> subscriberIterators =
        Lists.newArrayListWithCapacity(eventTypes.size());

    for (Class<?> eventType : eventTypes) {
      CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType);
      if (eventSubscribers != null) {
        // eager no-copy snapshot

    for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
      put(entry.getKey(), entry.getValue());
    }
  }

  @Override
  public void cleanUp() {}

  @Override
  public long size() {
    throw new UnsupportedOperationException();
  }

  @Override
  public void invalidate(Object key) {
    throw new UnsupportedOperationException();
  }

  /**
   * @since 11.0
   */

	return func() {
		duration := time.Since(startTime)

		atomic.AddUint64(&p.operations[s], 1)
		if s < scannerMetricLastRealtime {
			p.latency[s].add(duration)
		}
	}
}

// timeSize add time and size of a scanner action.
// Use for s < scannerMetricLastRealtime
func (p *scannerMetrics) timeSize(s scannerMetric) func(sz int) {
	startTime := time.Now()
	return func(sz int) {
		duration := time.Since(startTime)

        val buildFileComments = comments.values.first().stream().map { c: String -> "<" + (comments.values.first().indexOf(c) + 1) + "> " + c }.collect(Collectors.joining("\n"))
        val testFrameworkChoice = if (descriptor.testFrameworks.size > 1) """
Select test framework:
  1: JUnit 4
  2: TestNG
  3: Spock
  4: JUnit Jupiter
Enter selection (default: JUnit Jupiter) [1..4]
""" else ""

    }

    @Override
    public boolean apply(@ParametricNullness T t) {
      // Avoid using the Iterator to avoid generating garbage (issue 820).
      for (int i = 0; i < components.size(); i++) {
        if (!components.get(i).apply(t)) {
          return false;
        }
      }
      return true;
    }

    @Override
    public int hashCode() {

                        zos.putNextEntry(entry);
                        final long len = Files.copy(filePath, zos);
                        if (logger.isDebugEnabled()) {
                            logger.debug("Log file: name={}, size={}", filePath.getFileName(), len);
                        }
                    } catch (final IOException e) {
                        logger.warn("Failed to access {}", filePath, e);
                    }

                public Collection<Phase> phases() {
                    List<String> names = lifecycle.getPhases();
                    List<Phase> phases = new ArrayList<>();
                    for (int i = 0; i < names.size(); i++) {
                        String name = names.get(i);
                        String prev = i > 0 ? names.get(i - 1) : null;
                        phases.add(new Phase() {
                            @Override

		2 + // CRLF
		chunkDataSize +
		2 // CRLF
}

func mustGetPutObjReader(t TestErrHandler, data io.Reader, size int64, md5hex, sha256hex string) *PutObjReader {
	hr, err := hash.NewReader(context.Background(), data, size, md5hex, sha256hex, size)
	if err != nil {
		t.Fatal(err)
	}
	return NewPutObjReader(hr)
}