* Constructor for ICUNormalizer.
     * @param transliteratorId The ID of the transliterator to use.
     * @throws IllegalArgumentException if transliteratorId is null or invalid
     */
    public ICUNormalizer(final String transliteratorId) {
        if (transliteratorId == null) {
            throw new IllegalArgumentException("transliteratorId must not be null");
        }
        try {

        if (progressedSize < 0L) {
            throw new IllegalArgumentException("progressed file size cannot be negative: " + size);
        }
        if (size >= 0 && progressedSize > size) {
            throw new IllegalArgumentException(
                    "progressed file size cannot be greater than size: " + progressedSize + " > " + size);
        }

     * Constructs a ContentCache with the given byte array data.
     *
     * @param data the byte array containing the content
     * @throws IllegalArgumentException if data is null
     */
    public ContentCache(final byte[] data) {
        if (data == null) {
            throw new IllegalArgumentException("data must not be null");
        }
        this.data = data.clone();
        this.file = null;
    }

    /**

    void testConstructorWithNullHttpRequest(@Mock Principal mockPrincipal) {
        // HttpServletRequestWrapper throws IllegalArgumentException for null request
        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> new NtlmHttpServletRequest(null, mockPrincipal));
        assertEquals("Request cannot be null", ex.getMessage());
    }

    @Test

  @Test fun closeCodeOutOfRangeThrows() {
    assertFailsWith<IllegalArgumentException> {
      clientWriter.writeClose(98724976, "Hello".encodeUtf8())
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Code must be in range [1000,5000): 98724976")
    }
  }

  @Test fun closeReservedThrows() {
    assertFailsWith<IllegalArgumentException> {
      clientWriter.writeClose(1005, "Hello".encodeUtf8())

            }

        } catch (final Exception e) {
            throw new IllegalArgumentException("failed to build synonyms", e);
        }
    }

    private Reader getReader(final boolean reload) throws IOException {
        if (reload) {
            if (reloadableFile == null) {
                throw new IllegalArgumentException("reloadableFile is null.");
            }

        // Test that invalid valueOf throws exception
        assertThrows(IllegalArgumentException.class, () -> {
            WitnessServiceType.valueOf("INVALID_TYPE");
        });

        assertThrows(IllegalArgumentException.class, () -> {
            WitnessVersion.valueOf("INVALID_VERSION");
        });

        assertThrows(IllegalArgumentException.class, () -> {
            WitnessEventType.valueOf("INVALID_EVENT");

              e -> e instanceof ConcurrentModificationException)
          .put(ExecutionException.class, e -> e instanceof ExecutionException)
          .put(IllegalArgumentException.class, e -> e instanceof IllegalArgumentException)
          .put(IllegalStateException.class, e -> e instanceof IllegalStateException)
          .put(IndexOutOfBoundsException.class, e -> e instanceof IndexOutOfBoundsException)

 * limitations under the License.
 */
package okhttp3.internal.platform.android

import android.net.http.X509TrustManagerExtensions
import java.lang.IllegalArgumentException
import java.security.cert.Certificate
import java.security.cert.CertificateException
import java.security.cert.X509Certificate
import javax.net.ssl.SSLPeerUnverifiedException
import javax.net.ssl.X509TrustManager

  public void testCheckPositive_zeroInt() {
    assertThrows(IllegalArgumentException.class, () -> MathPreconditions.checkPositive("int", 0));
  }

  public void testCheckPositive_maxInt() {
    MathPreconditions.checkPositive("int", Integer.MAX_VALUE);
  }

  public void testCheckPositive_minInt() {
    assertThrows(
        IllegalArgumentException.class,
        () -> MathPreconditions.checkPositive("int", Integer.MIN_VALUE));