p = iface.indexOf('.', c + 1);
                    this.uuid = new UUID(iface.substring(0, c));
                    this.major = Integer.parseInt(iface.substring(c + 1, p));
                    this.minor = Integer.parseInt(iface.substring(p + 1));
                    return;
                }
            }
            throw new DcerpcException("Bad endpoint: " + this.endpoint);
        }

        final int originalValue;
        if (limitPercentage.endsWith("%")) {
            originalValue = Integer.parseInt(limitPercentage.substring(0, limitPercentage.length() - 1));
        } else {
            originalValue = Integer.parseInt(limitPercentage);
        }

        if (originalValue > 100) {
            this.limitPercentage = 100;
        } else if (originalValue < 1) {

  RoundingMode mode;

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      doubleInIntRange[i] = randomDouble(Integer.SIZE - 2);
      doubleInLongRange[i] = randomDouble(Long.SIZE - 2);
      positiveDoubles[i] = randomPositiveDouble();
    }
  }

  @Benchmark
  int roundToInt(int reps) {
    int tmp = 0;

                                "title": "Location",
                                "type": "array",
                                "items": {
                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },
                            },
                            "msg": {"title": "Message", "type": "string"},
                            "type": {"title": "Error Type", "type": "string"},

/**
 * @author higa
 *
 */
public class IntegerConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToInteger() throws Exception {
        assertEquals(Integer.valueOf("1000"), IntegerConversionUtil.toInteger("1,000"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveInt() throws Exception {

    assertHash(-189366624, murmur3_32().hashInt(-42));
    assertHash(-1134849565, murmur3_32().hashInt(42));
    assertHash(-1718298732, murmur3_32().hashInt(Integer.MIN_VALUE));
    assertHash(-1653689534, murmur3_32().hashInt(Integer.MAX_VALUE));
  }

  public void testKnownLongInputs() {
    assertHash(1669671676, murmur3_32().hashLong(0L));
    assertHash(-846261623, murmur3_32().hashLong(-42L));

  require(millis <= Integer.MAX_VALUE) { "$name too large" }
  require(millis != 0L || duration <= 0L) { "$name too small" }
  return millis.toInt()
}

internal fun checkDuration(
  name: String,
  duration: Duration,
): Int {
  check(!duration.isNegative()) { "$name < 0" }
  val millis = duration.inWholeMilliseconds
  require(millis <= Integer.MAX_VALUE) { "$name too large" }

        byte[] buffer = new byte[100];

        // Act & Assert
        assertEquals(0, response.readSetupWireFormat(buffer, 0, Integer.MAX_VALUE));
        assertEquals(0, response.readParametersWireFormat(buffer, 0, Integer.MAX_VALUE));
        assertEquals(0, response.readDataWireFormat(buffer, 0, Integer.MAX_VALUE));
    }

   */
  public static OptionalInt findLast(IntStream stream) {
    // findLast(Stream) does some allocation, so we might as well box some more
    java.util.Optional<Integer> boxedLast = findLast(stream.boxed());
    return boxedLast.map(OptionalInt::of).orElse(OptionalInt.empty());
  }

  /**
   * Returns the last element of the specified stream, or {@link OptionalLong#empty} if the stream

                                "title": "Location",
                                "type": "array",
                                "items": {
                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },
                            },
                            "msg": {"title": "Message", "type": "string"},
                            "type": {"title": "Error Type", "type": "string"},