state = RdmaConnectionState.ERROR;
            throw new IOException("TCP RDMA connection failed", e);
        }
    }

    @Override
    public void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED && state != RdmaConnectionState.CONNECTED) {
            throw new IOException("Connection not established");
        }

        try {

  }


  public void testWeak_afterGC() throws InterruptedException {
    MyInt canonical = new MyInt(5);
    MyInt not = new MyInt(5);

    Interner<MyInt> pool = Interners.newWeakInterner();
    assertSame(canonical, pool.intern(canonical));

    WeakReference<MyInt> signal = new WeakReference<>(canonical);
    canonical = null; // Hint to the JIT that canonical is unreachable

        ClosingFuture.submit(
            new ClosingCallable<Closeable>() {
              @Override
              public Closeable call(DeferredCloser closer) throws Exception {
                return closer.eventuallyClose(mockCloseable, executor);
              }
            },
            executor);
    closingFuture.finishToValueAndCloser(
        new NoOpValueAndCloserConsumer<>(), finishToValueAndCloserExecutor);

            _src.advance(1 * _nodes);

            if (node == null) {
                if (_nodes < 0 || _nodes > 0xFFFF) {
                    throw new NdrException(NdrException.INVALID_CONFORMANCE);
                }
                node = new byte[_nodes];
            }
            _src = _src.derive(_nodei);
            for (int _i = 0; _i < _nodes; _i++) {
                node[_i] = (byte) _src.dec_ndr_small();

        InputSource defaultBindings = new InputSource();
        defaultBindings.setModelId(DefaultLifecycleRegistry.DEFAULT_LIFECYCLE_MODELID);

        final Plugin plugin = mojoDescriptor.getPluginDescriptor().getPlugin();
        plugin.setLocation("version", new InputLocation(12, 34, defaultBindings));
        MojoExecution result = new MojoExecution(plugin, goal, executionId);

            UpgradeResult result1 = new UpgradeResult(
                    Set.of(pom1, pom2), // processed
                    Set.of(pom1), // modified
                    Set.of() // errors
                    );

            UpgradeResult result2 = new UpgradeResult(
                    Set.of(pom1), // processed (overlap)
                    Set.of(pom1, pom2), // modified (overlap + new)
                    Set.of() // errors

    return TypeToken.of(generateClass());
  }

  // io types
  @Generates
  File generateFile() {
    return new File(generateString());
  }

  @Generates
  static ByteArrayInputStream generateByteArrayInputStream() {
    return new ByteArrayInputStream(new byte[0]);
  }

  @Generates
  static InputStream generateInputStream() {
    return generateByteArrayInputStream();
  }

        throw new RuntimeException("Wrong length: " + x);
      }
    }
  }

  private static String oldRepeat(String string, int count) {
    // If this multiplication overflows, a NegativeArraySizeException or
    // OutOfMemoryError is not far behind
    int len = string.length();
    int size = len * count;
    char[] array = new char[size];
    for (int i = 0; i < size; i += len) {

    if (mockWebServer != null) throw new IllegalStateException();

    mockWebServer = new MockWebServer();
    mockWebServer.setDispatcher(this);
    mockWebServer.start(slackApi.port);
  }

  public HttpUrl newAuthorizeUrl(String scopes, String team, Listener listener) {
    if (mockWebServer == null) throw new IllegalStateException();

    ByteString state = randomToken();
    synchronized (this) {

                    } else {
                        populate(new InputStreamReader(new SmbFileInputStream(url)));
                    }
                } else if (line.startsWith("#BEGIN_ALTERNATE")) {
                    alt++;
                } else if (line.startsWith("#END_ALTERNATE") && alt > 0) {
                    alt--;
                    throw new IOException("no lmhosts alternate includes loaded");
                }