this.attributes = this.node.attributes().entrySet().stream()
                .filter(a -> a.getKey().equals(qname.getName()) || "*".equals(qname.getName()))
                .collect(Collectors.toList());
    }

    @Override
    public NodePointer getNodePointer() {
        if (position == 0) {
            setPosition(1);
        }

        final List<LabelType> list = labelTypeService.getLabelTypeList(pager);
        return asJson(
                new ApiResult.ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                        .total(pager.getAllRecordCount())
                        .status(ApiResult.Status.OK)
                        .result());
    }

    /**

            } else if (state == DfsState.VISITING) {
                // we are already visiting this vertex, this mean we have a cycle
                int pos = cycle.lastIndexOf(v.label);
                List<String> ret = cycle.subList(pos, cycle.size());
                ret.add(v.label);
                return ret;
            }
        }
        return null;
    }

    static class Vertex {
        final String label;

  @SuppressWarnings("rawtypes") // class literals
  @Override
  protected List<Class<? extends AbstractTester>> getTesters() {
    return Arrays.asList(
        CollectionAddAllTester.class,
        CollectionAddTester.class,
        CollectionClearTester.class,
        CollectionContainsAllTester.class,
        CollectionContainsTester.class,

   */
  static <T extends ForwardingObject> void testForwardingObject(Class<T> forwarderClass) {
    List<Class<?>> interfaces = new ArrayList<>(Arrays.asList(forwarderClass.getInterfaces()));
    // Desugaring may introduce AutoCloseable as an extra interface.
    interfaces.remove(AutoCloseable.class);
    @SuppressWarnings("unchecked") // super interface type of T

      for (int i = 0; i < minCopiesOfEachGoodQuery; i++) {
        queryList.addAll(elementsInSet);
      }
      List<Element> tmp = new ArrayList<>(elementsInSet);
      shuffle(tmp, random);
      queryList.addAll(tmp.subList(0, extras));
    }

    // now add bad queries
    while (queryList.size() < numQueries) {
      Element candidate = newElement();
      if (!elementsInSet.contains(candidate)) {
        queryList.add(candidate);

    val request = server.takeRequest()
    assertThat(request.body.readUtf8()).isEqualTo("request")
  }

  @Test
  fun testH2PriorKnowledgeServerFallback() {
    try {
      server.protocols = Arrays.asList(Protocol.H2_PRIOR_KNOWLEDGE, Protocol.HTTP_1_1)
      fail<Any>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo(

import com.google.common.collect.SortedMapDifference;
import com.google.common.collect.SortedMultiset;
import com.google.common.collect.SortedSetMultimap;
import com.google.common.collect.Table;
import com.google.common.collect.Tables;
import com.google.common.collect.TreeBasedTable;
import com.google.common.collect.TreeMultimap;
import com.google.common.io.ByteSink;
import com.google.common.io.ByteSource;
import com.google.common.io.ByteStreams;

      "$prefix/samples/guide/src/main/java/okhttp3/recipes/kt",
    ).map { File(it) }

  return directories.flatMap {
    it
      .listFiles()
      .orEmpty()
      .filter { f -> f.isFile }
      .toList()
  }
}

internal class MainTestProvider : SimpleProvider() {
  override fun arguments(): List<Any> {
    val mainFiles = mainFiles()
    return mainFiles
      .map {

            builder.getMainModule().set("jdk.httpserver");
            builder.setStandardOutput(System.out);
            builder.setErrorOutput(System.err);
            builder.setArgs(Arrays.asList("-p", getPort().get(), "-d", getDocsDirectory().get().getAsFile().getAbsolutePath()));
            registry.start(getPath(), DeploymentRegistry.ChangeBehavior.RESTART, JavaApplicationHandle.class, builder);
        }
    }