How to use

NamedWriteableRegistry

in

org.elasticsearch.common.io.stream

               .flatMap(p -> p.getNamedWriteables().stream())
               .collect(Collectors.toList()));
NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(entries);
NamedXContentRegistry xContentRegistry = new NamedXContentRegistry(Stream.of(
    searchModule.getNamedXContents().stream(),

  @Override
  public <C extends NamedWriteable> C readNamedWriteable(@SuppressWarnings("unused") Class<C> categoryClass,
                              @SuppressWarnings("unused") String name) throws IOException {
    Writeable.Reader<? extends C> reader = namedWriteableRegistry.getReader(categoryClass, name);
    C c = reader.read(this);
    if (c == null) {
      throw new IOException(
        "Writeable.Reader [" + reader + "] returned null which is not allowed and probably means it screwed up the stream.");
    }
    assert name.equals(c.getWriteableName()) : c + " claims to have a different name [" + c.getWriteableName()
      + "] than it was read from [" + name + "].";
    return c;
  }
}

public void registerTaskStatus(Task.Status prototype) {
  namedWriteableRegistry.registerPrototype(Task.Status.class, prototype);
}

  @Override
  <C> C readNamedWriteable(Class<C> categoryClass) throws IOException {
    String name = readString();
    NamedWriteable<? extends C> namedWriteable = namedWriteableRegistry.getPrototype(categoryClass, name);
    return namedWriteable.readFrom(this);
  }
}

/**
 * Get the {@link NamedWriteableRegistry} to use when de-serializing the object.
 * 
 * Override this method if you need to register {@link NamedWriteable}s for the test object to de-serialize.
 * 
 * By default this will return a {@link NamedWriteableRegistry} with no registered {@link NamedWriteable}s
 */
protected NamedWriteableRegistry getNamedWriteableRegistry() {
  return new NamedWriteableRegistry(Collections.emptyList());
}

@SuppressWarnings("unchecked")
private QB copyQuery(QB query) throws IOException {
  Reader<QB> reader = (Reader<QB>) serviceHolder.namedWriteableRegistry.getReader(QueryBuilder.class, query.getWriteableName());
  return copyWriteable(query, serviceHolder.namedWriteableRegistry, reader);
}

  /**
   * Get the {@link NamedWriteableRegistry} to use when de-serializing the object.
   *
   * Override this method if you need to register {@link NamedWriteable}s for the test object to de-serialize.
   *
   * By default this will return a {@link NamedWriteableRegistry} with no registered {@link NamedWriteable}s
   */
  protected NamedWriteableRegistry getNamedWriteableRegistry() {
    return new NamedWriteableRegistry(Collections.emptyList());
  }
}

  @Override
  public <C extends NamedWriteable> C readNamedWriteable(@SuppressWarnings("unused") Class<C> categoryClass,
                              @SuppressWarnings("unused") String name) throws IOException {
    Writeable.Reader<? extends C> reader = namedWriteableRegistry.getReader(categoryClass, name);
    C c = reader.read(this);
    if (c == null) {
      throw new IOException(
        "Writeable.Reader [" + reader + "] returned null which is not allowed and probably means it screwed up the stream.");
    }
    assert name.equals(c.getWriteableName()) : c + " claims to have a different name [" + c.getWriteableName()
      + "] than it was read from [" + name + "].";
    return c;
  }
}

  ClusterModule.getNamedWriteables().stream())
  .flatMap(Function.identity()).collect(Collectors.toList());
final NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(namedWriteables);
NamedXContentRegistry xContentRegistry = new NamedXContentRegistry(Stream.of(
  NetworkModule.getNamedXContents().stream(),

  @Override
  public <C extends NamedWriteable> C readNamedWriteable(@SuppressWarnings("unused") Class<C> categoryClass,
                              @SuppressWarnings("unused") String name) throws IOException {
    Writeable.Reader<? extends C> reader = namedWriteableRegistry.getReader(categoryClass, name);
    C c = reader.read(this);
    if (c == null) {
      throw new IOException(
        "Writeable.Reader [" + reader + "] returned null which is not allowed and probably means it screwed up the stream.");
    }
    assert name.equals(c.getWriteableName()) : c + " claims to have a different name [" + c.getWriteableName()
      + "] than it was read from [" + name + "].";
    return c;
  }
}

/**
 * The {@link NamedWriteableRegistry} to use for this test. Subclasses should override and use liberally.
 */
protected NamedWriteableRegistry writableRegistry() {
  return new NamedWriteableRegistry(ClusterModule.getNamedWriteables());
}

  @Override
  public <C extends NamedWriteable> C readNamedWriteable(@SuppressWarnings("unused") Class<C> categoryClass,
                              @SuppressWarnings("unused") String name) throws IOException {
    Writeable.Reader<? extends C> reader = namedWriteableRegistry.getReader(categoryClass, name);
    C c = reader.read(this);
    if (c == null) {
      throw new IOException(
        "Writeable.Reader [" + reader + "] returned null which is not allowed and probably means it screwed up the stream.");
    }
    assert name.equals(c.getWriteableName()) : c + " claims to have a different name [" + c.getWriteableName()
      + "] than it was read from [" + name + "].";
    return c;
  }
}

static NamedWriteableRegistry getNamedWriteableRegistry()
{
  IndicesModule indicesModule = new IndicesModule(Collections.emptyList());
  SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
  List<NamedWriteableRegistry.Entry> entries = new ArrayList<>();
  entries.addAll(indicesModule.getNamedWriteables());
  entries.addAll(searchModule.getNamedWriteables());
  return new NamedWriteableRegistry(entries);
}

private AB copyAggregation(AB agg) throws IOException {
  try (BytesStreamOutput output = new BytesStreamOutput()) {
    agg.writeTo(output);
    try (StreamInput in = new NamedWriteableAwareStreamInput(output.bytes().streamInput(), namedWriteableRegistry)) {
      @SuppressWarnings("unchecked")
      AB secondAgg = (AB) namedWriteableRegistry.getReader(AggregationBuilder.class, agg.getWriteableName()).read(in);
      return secondAgg;
    }
  }
}

static NamedWriteableRegistry getNamedWriteableRegistry()
{
  IndicesModule indicesModule = new IndicesModule(Collections.emptyList());
  SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
  List<NamedWriteableRegistry.Entry> entries = new ArrayList<>();
  entries.addAll(indicesModule.getNamedWriteables());
  entries.addAll(searchModule.getNamedWriteables());
  return new NamedWriteableRegistry(entries);
}

public static MockTransportService createNewService(Settings settings, Version version, ThreadPool threadPool,
                          @Nullable ClusterSettings clusterSettings) {
  // some tests use MockTransportService to do network based testing. Yet, we run tests in multiple JVMs that means
  // concurrent tests could claim port that another JVM just released and if that test tries to simulate a disconnect it might
  // be smart enough to re-connect depending on what is tested. To reduce the risk, since this is very hard to debug we use
  // a different default port range per JVM unless the incoming settings override it
  int basePort = 10300 + (JVM_ORDINAL * 100); // use a non-default port otherwise some cluster in this JVM might reuse a port
  settings = Settings.builder().put(TcpTransport.PORT.getKey(), basePort + "-" + (basePort + 100)).put(settings).build();
  NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(ClusterModule.getNamedWriteables());
  final Transport transport = new MockTcpTransport(settings, threadPool, BigArrays.NON_RECYCLING_INSTANCE,
    new NoneCircuitBreakerService(), namedWriteableRegistry, new NetworkService(Collections.emptyList()), version);
  return createNewService(settings, transport, version, threadPool, clusterSettings, Collections.emptySet());
}

/**
 * Setup for the whole base test class.
 */
@Override
public void setUp() throws Exception {
  super.setUp();
  Settings settings = Settings.builder()
    .put("node.name", AbstractQueryTestCase.class.toString())
    .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir())
    .build();
  IndicesModule indicesModule = new IndicesModule(Collections.emptyList());
  PluginsService pluginsService = new PluginsService(settings, null, null, null, getPlugins());
  SearchModule searchModule = new SearchModule(settings, false, pluginsService.filterPlugins(SearchPlugin.class));
  List<NamedWriteableRegistry.Entry> entries = new ArrayList<>();
  entries.addAll(indicesModule.getNamedWriteables());
  entries.addAll(searchModule.getNamedWriteables());
  namedWriteableRegistry = new NamedWriteableRegistry(entries);
  xContentRegistry = new NamedXContentRegistry(searchModule.getNamedXContents());
  //create some random type with some default field, those types will stick around for all of the subclasses
  currentTypes = new String[randomIntBetween(0, 5)];
  for (int i = 0; i < currentTypes.length; i++) {
    String type = randomAlphaOfLengthBetween(1, 10);
    currentTypes[i] = type;
  }
}

final SearchRequest deserializedRequest = new SearchRequest();
StreamInput streamInput = new ByteBufferStreamInput(ByteBuffer.wrap(slice));
NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry();
try (StreamInput in = new NamedWriteableAwareStreamInput(streamInput, namedWriteableRegistry)) {
  deserializedRequest.readFrom(in);

public void testHandshakeWithIncompatVersion() {
  assumeTrue("only tcp transport has a handshake method", serviceA.getOriginalTransport() instanceof TcpTransport);
  NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(Collections.emptyList());
  Version version = Version.fromString("2.0.0");
  try (MockTcpTransport transport = new MockTcpTransport(Settings.EMPTY, threadPool, BigArrays.NON_RECYCLING_INSTANCE,
    new NoneCircuitBreakerService(), namedWriteableRegistry, new NetworkService(Collections.emptyList()), version);
     MockTransportService service = MockTransportService.createNewService(Settings.EMPTY, transport, version, threadPool, null,
       Collections.emptySet())) {
    service.start();
    service.acceptIncomingRequests();
    DiscoveryNode node =
      new DiscoveryNode("TS_TPC", "TS_TPC", transport.boundAddress().publishAddress(), emptyMap(), emptySet(), version0);
    ConnectionProfile.Builder builder = new ConnectionProfile.Builder();
    builder.addConnections(1,
      TransportRequestOptions.Type.BULK,
      TransportRequestOptions.Type.PING,
      TransportRequestOptions.Type.RECOVERY,
      TransportRequestOptions.Type.REG,
      TransportRequestOptions.Type.STATE);
    expectThrows(ConnectTransportException.class, () -> serviceA.openConnection(node, builder.build()));
  }
}

public abstract class InternalAggregationTestCase<T extends InternalAggregation> extends AbstractWireSerializingTestCase<T> {
  public static final int DEFAULT_MAX_BUCKETS = 100000;
  private final NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(
      new SearchModule(Settings.EMPTY, false, emptyList()).getNamedWriteables());