/** Configures this builder produce a TestSuite with the given name. */
  @CanIgnoreReturnValue
  public B named(String name) {
    if (name.contains("(")) {
      throw new IllegalArgumentException(
          "Eclipse hides all characters after "
              + "'('; please use '[]' or other characters instead of parentheses");
    }
    this.name = name;
    return self();
  }

  override fun parse(string: String): MediaType = string.toMediaType()

  override fun assertInvalid(
    string: String,
    exceptionMessage: String?,
  ) {
    val e =
      assertFailsWith<IllegalArgumentException> {
        parse(string)
      }
    assertEquals(exceptionMessage, e.message)
  }

  public void testCheckArgument_nullMessage_failure() {
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> checkArgument(false, null));
    assertThat(expected).hasMessageThat().isEqualTo("null");
  }

  public void testCheckArgument_nullMessageWithArgs_failure() {
    IllegalArgumentException e =
        assertThrows(IllegalArgumentException.class, () -> checkArgument(false, null, "b", "d"));

    return certificates.single() as X509Certificate
  } catch (nsee: NoSuchElementException) {
    throw IllegalArgumentException("failed to decode certificate", nsee)
  } catch (iae: IllegalArgumentException) {
    throw IllegalArgumentException("failed to decode certificate", iae)
  } catch (e: GeneralSecurityException) {
    throw IllegalArgumentException("failed to decode certificate", e)
  }
}

/**

    graph.putEdgeValue(1, 2, "A");
    IllegalArgumentException e =
        assertThrows(
            IllegalArgumentException.class, () -> graph.edgeValue(EndpointPair.unordered(1, 2)));
    assertThat(e).hasMessageThat().contains(ENDPOINTS_MISMATCH);
    e =
        assertThrows(
            IllegalArgumentException.class, () -> graph.edgeValue(EndpointPair.unordered(2, 1)));

      },
    ).hasMessage("timeout < 0")
    assertThat(
      assertThrows<IllegalArgumentException> {
        checkDuration("timeout", 1, TimeUnit.NANOSECONDS)
      },
    ).hasMessage("timeout too small")
    assertThat(
      assertThrows<IllegalArgumentException> {
        checkDuration(
          "timeout",
          1L + Int.MAX_VALUE.toLong(),
          TimeUnit.MILLISECONDS,

    addEdge(N1, N2, E12);
    IllegalArgumentException e =
        assertThrows(
            IllegalArgumentException.class,
            () -> networkAsMutableNetwork.addEdge(N1, N2, EDGE_NOT_IN_GRAPH));
    assertThat(e).hasMessageThat().contains(ERROR_PARALLEL_EDGE);
    e =
        assertThrows(
            IllegalArgumentException.class,

        assertTrue(checker.matchesVersion("1.8", "9.0.1+11"));
        assertFalse(checker.matchesVersion("[1.0,2],[3,4]", "2.1"));
        assertTrue(checker.matchesVersion("[1.0,2],[3,4]", "3.1"));
        assertThrows(IllegalArgumentException.class, () -> checker.matchesVersion("(1.0,0)", "11"));
    }

            val implementationClass = pluginProperties.getProperty("implementation-class")
            PluginEntry(id, implementationClass)
        }.toList()
    }
} catch (cause: IOException) {
    throw IllegalArgumentException(
        "Failed to extract plugin metadata from '" + jar.path + "'",
        cause
    )
}


private
fun isGradlePluginPropertiesFile(entry: JarEntry) = entry.run {

    graph.putEdgeValue(1, 2, "A");
    IllegalArgumentException e =
        assertThrows(
            IllegalArgumentException.class,
            () -> graph.edgeValueOrDefault(EndpointPair.unordered(1, 2), "default"));
    assertThat(e).hasMessageThat().contains(ENDPOINTS_MISMATCH);
    e =
        assertThrows(
            IllegalArgumentException.class,