throw new IllegalStateException("Dumb terminal detected.\nThis tool requires real terminal to work!\n"
                        + "Note: On Windows Jansi or JNA library must be included in classpath.");
            } else if (OSUtils.IS_WINDOWS) {
                config = new ConsolePrompt.UiConfig(">", "( )", "(x)", "( )");
            } else {

                            String goalPrefix = mayGetChild(root, "goalPrefix");
                            String name = mayGetChild(root, "name");
                            // sanity check: plugin descriptor extracted from artifact must have same GA
                            if (Objects.equals(artifact.getGroupId(), groupId)
                                    && Objects.equals(artifact.getArtifactId(), artifactId)) {

		t.Log("Roundtrip:", time.Since(start), resp, err)
		gotResp <- struct{}{}
	}()
	<-gotCall
	remote.debugMsg(debugKillInbound)
	local.debugMsg(debugKillInbound)
	<-gotResp

	// Must reconnect
	errFatal(remoteConn.WaitForConnect(context.Background()))

	stream, err := remoteConn.NewStream(context.Background(), handlerTest2, []byte(testPayload))
	errFatal(err)
	go func() {

        List<E> castedList = (List<E>) list;
        return new RegularImmutableList<E>(castedList);
    }
  }

  /**
   * Views the array as an immutable list. The array must have only {@code E} elements.
   *
   * <p>The array must be internally created.
   */
  @SuppressWarnings("unchecked") // caller is reponsible for getting this right
  static <E> ImmutableList<E> asImmutableList(Object[] elements) {

    assertEquals("BigInteger must be greater than or equal to 0", expected.getMessage());
  }

  public void testFromIpv6BigIntegerThrowsLessThanZero() {
    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,
            () -> InetAddresses.fromIPv6BigInteger(BigInteger.valueOf(-1L)));
    assertEquals("BigInteger must be greater than or equal to 0", expected.getMessage());

  /**
   * Returns the stripe at the specified index. Valid indexes are 0, inclusively, to {@code size()},
   * exclusively.
   *
   * @param index the index of the stripe to return; must be in {@code [0...size())}
   * @return the stripe at the specified index
   */
  public abstract L getAt(int index);

  /**

            throw new SmbException( "Signature verification failed." );
        }
    }
    void send( ServerMessageBlock request, ServerMessageBlock response ) throws SmbException {

        connect(); /* must negotiate before we can test flags2, useUnicode, etc */

        request.flags2 |= flags2;
        request.useUnicode = useUnicode;
        request.response = response; /* needed by sign */

    @Override
    public void validateClass(Class<? extends Exception> exceptionClass) {
      checkArgument(
          isCheckedException(exceptionClass),
          "Futures.getChecked exception type (%s) must not be a RuntimeException",
          exceptionClass);
    }
  }

  private static GetCheckedTypeValidator nonCachingWithConstructorCheckValidator() {
    return NonCachingWithConstructorCheckValidator.INSTANCE;

    opcode: Int,
    payload: ByteString,
  ) {
    if (writerClosed) throw IOException("closed")

    val length = payload.size
    require(length <= PAYLOAD_BYTE_MAX) {
      "Payload size must be less than or equal to $PAYLOAD_BYTE_MAX"
    }

    val b0 = B0_FLAG_FIN or opcode
    sinkBuffer.writeByte(b0)

    var b1 = length
    if (isClient) {
      b1 = b1 or B1_FLAG_MASK

    } finally {
      cancelInFlightConnects()
    }

    throw firstException!!
  }

  /**
   * Returns non-null if we don't need to wait for the launched result. In such cases, this result
   * must be processed before whatever is waiting in the queue because we may have already acquired
   * its connection.
   */
  private fun launchTcpConnect(): ConnectResult? {
    val plan =
      when {