@CollectionSize.Require(SEVERAL)
  public void testSetValue_valuePresent() {
    for (Entry<K, V> entry : getMap().entrySet()) {
      if (entry.getKey().equals(k0())) {
        assertThrows(IllegalArgumentException.class, () -> entry.setValue(v1()));
      }
    }
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES)
  @CollectionSize.Require(absent = ZERO)

    assertThat("⑴".map()).isEqualTo("(1)")
  }

  @Test fun outOfBounds() {
    assertFailsWith<IllegalArgumentException> {
      table.map(-1, Buffer())
    }
    table.map(0, Buffer()) // Lowest legal code point.
    table.map(0x10ffff, Buffer()) // Highest legal code point.
    assertFailsWith<IllegalArgumentException> {
      table.map(0x110000, Buffer())
    }
  }

  @Test fun binarySearchEvenSizedRange() {

        assertEquals("another", result.get(2));
    }

    @Test(expected = IllegalArgumentException.class)
    public void testGetAsListWithArray() {
        // Test with array (should throw exception)
        String[] array = { "one", "two" };
        SuggestUtil.getAsList(array);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testGetAsListWithDouble() {

    val multipart = MultipartBody.Builder()
    assertFailsWith<IllegalArgumentException> {
      multipart.addPart(
        headersOf("Content-Type", "text/plain"),
        "Hello, World!".toRequestBody(null),
      )
    }
  }

  @Test
  fun contentLengthHeaderIsForbidden() {
    val multipart = MultipartBody.Builder()
    assertFailsWith<IllegalArgumentException> {
      multipart.addPart(

    switch (edgesConnecting.size()) {
      case 0:
        return null;
      case 1:
        return edgesConnecting.iterator().next();
      default:
        throw new IllegalArgumentException(String.format(MULTIPLE_EDGES_CONNECTING, nodeU, nodeV));
    }
  }

  @Override
  public @Nullable E edgeConnectingOrNull(EndpointPair<N> endpoints) {
    validateEndpoints(endpoints);

      if (instance != null) {
        if (instance.getCause() == null) {
          instance.initCause(cause);
        }
        return instance;
      }
    }
    throw new IllegalArgumentException(
        "No appropriate constructor for exception of type "
            + exceptionClass
            + " in response to chained exception",
        cause);
  }

  RESTRICTS_VALUES,
  SUPPORTS_PUT,
  SUPPORTS_REMOVE,
  FAILS_FAST_ON_CONCURRENT_MODIFICATION,
  /**
   * Indicates that the constructor or factory method of a map, usually an immutable map, throws an
   * {@link IllegalArgumentException} when presented with duplicate keys instead of discarding all
   * but one.
   */
  REJECTS_DUPLICATES_AT_CREATION,

  GENERAL_PURPOSE(SUPPORTS_PUT, SUPPORTS_REMOVE);

  @Test
  fun requestHeaderValidationIsStrict() {
    assertFailsWith<IllegalArgumentException> {
      Request
        .Builder()
        .addHeader("a\tb", "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      Request
        .Builder()
        .addHeader("Name", "c\u007fd")
    }
    assertFailsWith<IllegalArgumentException> {
      Request
        .Builder()

        Exception cause = new IllegalArgumentException("Root cause");
        Exception exception = new RuntimeException("Wrapper exception", cause);

        monitorTarget.appendException(buf, exception);
        assertTrue(buf.toString().contains("Wrapper exception"));
        assertTrue(buf.toString().contains("Root cause"));
        assertTrue(buf.toString().contains("IllegalArgumentException"));
    }

     *
     * @param request the request containing the various data
     * @return a new {@link DependencyCoordinates} object
     *
     * @throws IllegalArgumentException if {@code request} is null or
     *         if {@code request.getSession()} is null or invalid
     */
    @Nonnull
    DependencyCoordinates create(@Nonnull DependencyCoordinatesFactoryRequest request);